added bfs and operator<< methods

examples/bfsExample.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include "../include/GraphMatrix.hpp"
+
+class Vertex : public Appledore::GraphVertex {
+    public:
+        int data;
+        Vertex(int d): data(d) {};
+};
+
+int main() {
+
+    // In order to use bfs, EdgeType must support the operator+ and must have
+    // infinity.
+    Appledore::GraphMatrix<Vertex, double, Appledore::UndirectedG> undirected;
+
+    Vertex v1(4);
+    Vertex v2(10);
+    Vertex v3(12);
+    Vertex v4(2);
+
+    undirected.addVertex(v1);
+    undirected.addVertex(v2);
+    undirected.addVertex(v3);
+    undirected.addVertex(v4);
+
+    undirected.addEdge(v1,v2,1);
+    undirected.addEdge(v2,v3,1);
+    undirected.addEdge(v1,v4,1);
+
+    std::vector<double> dist = undirected.bfs(2, 10);
+
+    for (int item : dist) {
+        std::cout << item << " ";
+    }
+    std::cout << "\n";
+    return 0;
+}

include/GraphMatrix.hpp

@@ -8,7 +8,10 @@
 #include <stack>
 #include <algorithm>
 #include <set>
+#include <queue>
+#include <limits>
 #include "MatrixRep.hpp"
+
 namespace Appledore
 {
 
@@ -518,6 +521,31 @@ namespace Appledore
             }
         }
 
+        std::vector<EdgeType> bfs(size_t start, size_t maxDepth) {
+            EdgeType inf = std::numeric_limits<EdgeType>::infinity();
+            std::vector<EdgeType> dist(numVertices, inf);
+            dist[start] = 0;
+
+            std::queue<VertexType> queue;
+            queue.push(indexToVertex[start]);
+            size_t depth = 0;
+
+            while (!queue.empty() && depth <= maxDepth) {
+                VertexType current = queue.front();
+                queue.pop();
+                depth = dist[vertexToIndex[current]];
+
+                for (VertexType neighbor : getNeighbors(current)) {
+                    EdgeType weight = getEdge(current, neighbor);
+                    if (dist[vertexToIndex[neighbor]] == inf) {
+                        dist[vertexToIndex[neighbor]] = dist[vertexToIndex[current]] + weight;
+                        queue.push(neighbor);
+                    }
+                }
+            }
+            return dist;
+        }; 
+
         // ---------------------------------------------------------
         // NEW METHOD: removeVertex()
         // ---------------------------------------------------------
@@ -623,6 +651,23 @@ namespace Appledore
             }
         }
 
+    friend std::ostream& operator<<(std::ostream& src, const GraphMatrix& other) {
+        src << "GraphMatrix Object:\n";
+        src << "\tVertex List:\n";
+        std::vector<VertexType> vertices = other.getVertices();
+        for (VertexType vertex : vertices) {
+            src << "\t\t" << vertex << std::endl;
+        }
+
+        src << "\tEdge List:\n";
+        for (VertexType incident : vertices) {
+            for (VertexType terminal : other.getNeighbors(incident)) {
+                src << "\t\t " << incident << "-->" << terminal << std::endl;
+            }
+        }
+        return src;
+    }
+
     private:
         std::map<VertexType, size_t> vertexToIndex;
         std::vector<VertexType> indexToVertex;

include/MatrixRep.hpp

@@ -39,6 +39,11 @@ namespace Appledore
         {
             return id == other.id;
         }
+
+        friend std::ostream& operator<<(std::ostream& src, const GraphVertex& other) {
+            src << "Vertex " << other.id;
+            return src;
+        }
     };
     size_t Appledore::GraphVertex::nextId = 1;
     class GraphEdge