Implemented adjacencyListIn member variable: Fixes #406, Fixes #501 (#526)

* Added visual studio to .gitignore

* Implemented cachedAdjMatrixIn functionality, resolving #406:
- Implemented cachedAdjMatrixIn member variable
- Renamed cachedAdjMatrix -> cachedAdjMatrixOut and cachedAdjMatrix -> cachedAdjMatricies to reflect changes
- Renamed inNeighbors/Edges -> inNotOutNeighbors/Edges and inOutNeighbors/Edges -> inOrOutNeighbors/Edges for clarity
- Fixed inOrOutNeighbors/Edges, resolving #406
- Added #406 replicator as a test in DirectedEdgeTest

* Implemented inNotOutEdges/Neighbors and associated tests for completeness with outNotInEdges/Neighbors

* Renamed adjacency matrix in/out -> adjacency list in/out to better reflect their implementation

Author: brghash

.gitignore

@@ -39,3 +39,5 @@ packaging/
 .vscode
 .code-workspace
 CXXGraph.code-workspace
+# ignore visual studio files
+.vs

benchmark/Graph_BM.cpp

@@ -122,7 +122,7 @@ static void getAdjMatrixX(benchmark::State &state) {
     g.addEdge(&(*e.second));
   }
   for (auto _ : state) {
-    auto adjMatrix = g.getAdjMatrix();
+    auto adjMatrix = g.getAdjListOut();
   }
   state.SetComplexityN(2);
 }
@@ -134,7 +134,7 @@ BENCHMARK(getAdjMatrixX)
 
 static void getAdjMatrixCitHep(benchmark::State &state) {
   for (auto _ : state) {
-    auto adjMatrix = cit_graph_ptr->getAdjMatrix();
+    auto adjMatrix = cit_graph_ptr->getAdjListOut();
   }
   state.SetComplexityN(2);
 }

examples/DijkstraExample/dijkstra_example.cpp

@@ -28,9 +28,9 @@ int main() {
 
   CXXGraph::Graph<int> graph(edgeSet);
   auto res = graph.dijkstra(node0, node3);
-  
+
   std::cout << "Dijkstra Result: " << res.result << "\n";
-  for(auto& name : res.path) {
+  for (auto& name : res.path) {
     std::cout << "->" << name << std::endl;
   }
 
@@ -39,7 +39,7 @@ int main() {
 
   std::cout << "CP Result: " << res.result << "\n";
   std::cout << "CP path size: " << res.path.size() << "\n";
-  for(auto& name : res.path) {
+  for (auto& name : res.path) {
     std::cout << "->" << name << std::endl;
   }
 

include/CXXGraph/Graph/Algorithm/BestFirstSearch_impl.hpp

@@ -69,8 +69,8 @@ BestFirstSearchResult<T> Graph<T>::best_first_search(
     if (*currentNode == target) {
       break;
     }
-    if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-      for (const auto &elem : cachedAdjMatrix->at(currentNode)) {
+    if (cachedAdjListOut->find(currentNode) != cachedAdjListOut->end()) {
+      for (const auto &elem : cachedAdjListOut->at(currentNode)) {
         if (elem.second->isWeighted().has_value()) {
           if (elem.second->isDirected().has_value()) {
             shared<const DirectedWeightedEdge<T>> dw_edge =
@@ -190,8 +190,8 @@ const std::vector<Node<T>> Graph<T>::concurrency_breadth_first_search(
         }
 
         for (int i = start_index; i < end_index; ++i) {
-          if (cachedAdjMatrix->count(level_tracker[i])) {
-            for (const auto &elem : cachedAdjMatrix->at(level_tracker[i])) {
+          if (cachedAdjListOut->count(level_tracker[i])) {
+            for (const auto &elem : cachedAdjListOut->at(level_tracker[i])) {
               int index = (int)node_to_index[elem.first];
               if (visited[index] == 0) {
                 visited[index] = 1;

include/CXXGraph/Graph/Algorithm/BreadthFirstSearch_impl.hpp

@@ -50,8 +50,8 @@ const std::vector<Node<T>> Graph<T>::breadth_first_search(
   while (!tracker.empty()) {
     shared<const Node<T>> node = tracker.front();
     tracker.pop();
-    if (cachedAdjMatrix->find(node) != cachedAdjMatrix->end()) {
-      for (const auto &elem : cachedAdjMatrix->at(node)) {
+    if (cachedAdjListOut->find(node) != cachedAdjListOut->end()) {
+      for (const auto &elem : cachedAdjListOut->at(node)) {
         // if the node is not visited then mark it as visited
         // and push it to the queue
         if (std::find(visited.begin(), visited.end(), *(elem.first)) ==

include/CXXGraph/Graph/Algorithm/BronKerbosch_impl.hpp

@@ -49,7 +49,7 @@ const BronKerboschResult<T> Graph<T>::bron_kerbosch() const {
         auto it = P.begin();
         while (it != P.end()) {
           const auto v = *it;
-          T_NodeSet<T> X2, R2(R), P2, nbd(inOutNeighbors(v));
+          T_NodeSet<T> X2, R2(R), P2, nbd(inOrOutNeighbors(v));
           R2.insert(v);
           for (const auto &u : nbd) {
             if (X.count(u) > 0 && u != v) {

include/CXXGraph/Graph/Algorithm/Connectivity_impl.hpp

@@ -43,9 +43,9 @@ bool Graph<T>::isConnectedGraph() const {
           visited[source->getId()] = true;
 
           // travel the neighbors
-          for (size_t i = 0; i < (*cachedAdjMatrix)[source].size(); i++) {
+          for (size_t i = 0; i < (*cachedAdjListOut)[source].size(); i++) {
             shared<const Node<T>> neighbor =
-                (*cachedAdjMatrix)[source].at(i).first;
+                (*cachedAdjListOut)[source].at(i).first;
             if (visited[neighbor->getId()] == false) {
               // make recursive call from neighbor
               dfs_helper(neighbor);
@@ -83,9 +83,9 @@ bool Graph<T>::isStronglyConnectedGraph() const {
             visited[source->getId()] = true;
 
             // travel the neighbors
-            for (size_t i = 0; i < (*cachedAdjMatrix)[source].size(); i++) {
+            for (size_t i = 0; i < (*cachedAdjListOut)[source].size(); i++) {
               shared<const Node<T>> neighbor =
-                  (*cachedAdjMatrix)[source].at(i).first;
+                  (*cachedAdjListOut)[source].at(i).first;
               if (visited[neighbor->getId()] == false) {
                 // make recursive call from neighbor
                 dfs_helper(neighbor);

include/CXXGraph/Graph/Algorithm/CycleDetection_impl.hpp

@@ -54,13 +54,13 @@ bool Graph<T>::isCyclicDirectedGraphDFS() const {
     // node as it has already been checked for presence of cycle.
     if (state[node->getId()] == not_visited) {
       // Check for cycle.
-      std::function<bool(const std::shared_ptr<AdjacencyMatrix<T>>,
+      std::function<bool(const std::shared_ptr<AdjacencyList<T>>,
                          std::unordered_map<CXXGraph::id_t, nodeStates> &,
                          shared<const Node<T>>)>
           isCyclicDFSHelper;
       isCyclicDFSHelper =
           [&isCyclicDFSHelper](
-              const std::shared_ptr<AdjacencyMatrix<T>> adjMatrix,
+              const std::shared_ptr<AdjacencyList<T>> adjMatrix,
               std::unordered_map<CXXGraph::id_t, nodeStates> &states,
               shared<const Node<T>> node) {
             // Add node "in_stack" state.
@@ -94,7 +94,7 @@ bool Graph<T>::isCyclicDirectedGraphDFS() const {
             // Return that current node didn't result in any cycles.
             return false;
           };
-      if (isCyclicDFSHelper(cachedAdjMatrix, state, node)) {
+      if (isCyclicDFSHelper(cachedAdjListOut, state, node)) {
         return true;
       }
     }
@@ -184,7 +184,7 @@ bool Graph<T>::isCyclicDirectedGraphBFS() const {
     indegree[node->getId()] = 0;
   }
   // Calculate the indegree i.e. the number of incident edges to the node.
-  for (auto const &list : (*cachedAdjMatrix)) {
+  for (auto const &list : (*cachedAdjListOut)) {
     auto children = list.second;
     for (auto const &child : children) {
       indegree[std::get<0>(child)->getId()]++;
@@ -211,8 +211,8 @@ bool Graph<T>::isCyclicDirectedGraphBFS() const {
     remain--;
 
     // Visit all the children of the visited node.
-    auto it = cachedAdjMatrix->find(solved);
-    if (it != cachedAdjMatrix->end()) {
+    auto it = cachedAdjListOut->find(solved);
+    if (it != cachedAdjListOut->end()) {
       for (const auto &child : it->second) {
         // Check if we can visited the node safely.
         if (--indegree[std::get<0>(child)->getId()] == 0) {

include/CXXGraph/Graph/Algorithm/DepthFirstSearch_impl.hpp

@@ -41,10 +41,10 @@ const std::vector<Node<T>> Graph<T>::depth_first_search(
   if (start_node_it == nodeSet.end()) {
     return visited;
   }
-  std::function<void(const std::shared_ptr<AdjacencyMatrix<T>>,
+  std::function<void(const std::shared_ptr<AdjacencyList<T>>,
                      shared<const Node<T>>, std::vector<Node<T>> &)>
       explore;
-  explore = [&explore](const std::shared_ptr<AdjacencyMatrix<T>> adj,
+  explore = [&explore](const std::shared_ptr<AdjacencyList<T>> adj,
                        shared<const Node<T>> node,
                        std::vector<Node<T>> &visited) -> void {
     visited.push_back(*node);
@@ -57,7 +57,7 @@ const std::vector<Node<T>> Graph<T>::depth_first_search(
       }
     }
   };
-  explore(cachedAdjMatrix, *start_node_it, visited);
+  explore(cachedAdjListOut, *start_node_it, visited);
 
   return visited;
 }

include/CXXGraph/Graph/Algorithm/Dial_impl.hpp

@@ -84,7 +84,7 @@ const DialResult Graph<T>::dial(const Node<T> &source, int maxWeight) const {
 
     // Process all adjacents of extracted vertex 'u' and
     // update their distanced if required.
-    for (const auto &i : (*cachedAdjMatrix)[u]) {
+    for (const auto &i : (*cachedAdjListOut)[u]) {
       auto v = i.first;
       int weight = 0;
       if (i.second->isWeighted().has_value() &&