Implemented cachedAdjMatrixIn functionality, resolving #406:

brghash · brghash · commit 2f73b59d4d90 · 2025-08-29T17:59:24.000+01:00
- 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
diff --git a/benchmark/Graph_BM.cpp b/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.getAdjMatrixOut();
   }
   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->getAdjMatrixOut();
   }
   state.SetComplexityN(2);
 }
diff --git a/include/CXXGraph/Graph/Algorithm/BestFirstSearch_impl.hpp b/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 (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+      for (const auto &elem : cachedAdjMatrixOut->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 (cachedAdjMatrixOut->count(level_tracker[i])) {
+            for (const auto &elem : cachedAdjMatrixOut->at(level_tracker[i])) {
               int index = (int)node_to_index[elem.first];
               if (visited[index] == 0) {
                 visited[index] = 1;
diff --git a/include/CXXGraph/Graph/Algorithm/BreadthFirstSearch_impl.hpp b/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 (cachedAdjMatrixOut->find(node) != cachedAdjMatrixOut->end()) {
+      for (const auto &elem : cachedAdjMatrixOut->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)) ==
diff --git a/include/CXXGraph/Graph/Algorithm/BronKerbosch_impl.hpp b/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) {
diff --git a/include/CXXGraph/Graph/Algorithm/Connectivity_impl.hpp b/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 < (*cachedAdjMatrixOut)[source].size(); i++) {
             shared<const Node<T>> neighbor =
-                (*cachedAdjMatrix)[source].at(i).first;
+                (*cachedAdjMatrixOut)[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 < (*cachedAdjMatrixOut)[source].size(); i++) {
               shared<const Node<T>> neighbor =
-                  (*cachedAdjMatrix)[source].at(i).first;
+                  (*cachedAdjMatrixOut)[source].at(i).first;
               if (visited[neighbor->getId()] == false) {
                 // make recursive call from neighbor
                 dfs_helper(neighbor);
diff --git a/include/CXXGraph/Graph/Algorithm/CycleDetection_impl.hpp b/include/CXXGraph/Graph/Algorithm/CycleDetection_impl.hpp
@@ -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(cachedAdjMatrixOut, 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 : (*cachedAdjMatrixOut)) {
     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 = cachedAdjMatrixOut->find(solved);
+    if (it != cachedAdjMatrixOut->end()) {
       for (const auto &child : it->second) {
         // Check if we can visited the node safely.
         if (--indegree[std::get<0>(child)->getId()] == 0) {
diff --git a/include/CXXGraph/Graph/Algorithm/DepthFirstSearch_impl.hpp b/include/CXXGraph/Graph/Algorithm/DepthFirstSearch_impl.hpp
@@ -57,7 +57,7 @@ const std::vector<Node<T>> Graph<T>::depth_first_search(
       }
     }
   };
-  explore(cachedAdjMatrix, *start_node_it, visited);
+  explore(cachedAdjMatrixOut, *start_node_it, visited);
 
   return visited;
 }
diff --git a/include/CXXGraph/Graph/Algorithm/Dial_impl.hpp b/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 : (*cachedAdjMatrixOut)[u]) {
       auto v = i.first;
       int weight = 0;
       if (i.second->isWeighted().has_value() &&
diff --git a/include/CXXGraph/Graph/Algorithm/Dijkstra_impl.hpp b/include/CXXGraph/Graph/Algorithm/Dijkstra_impl.hpp
@@ -52,7 +52,7 @@ const DijkstraResult Graph<T>::dijkstra(const Node<T>& source,
   }
   // n denotes the number of vertices in graph
   // unused
-  // auto n = cachedAdjMatrix->size();
+  // auto n = cachedAdjMatrixOut->size();
 
   // setting all the distances initially to INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
@@ -88,8 +88,8 @@ const DijkstraResult Graph<T>::dijkstra(const Node<T>& source,
 
     // for all the reachable vertex from the currently exploring vertex
     // we will try to minimize the distance
-    if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-      for (const auto& elem : cachedAdjMatrix->at(currentNode)) {
+    if (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
         // minimizing distances
         if (elem.second->isWeighted().has_value() &&
             elem.second->isWeighted().value()) {
@@ -177,7 +177,7 @@ const DijkstraResult Graph<T>::dijkstra_deterministic(
   }
   // n denotes the number of vertices in graph
   // unused
-  // auto n = cachedAdjMatrix->size();
+  // auto n = cachedAdjMatrixOut->size();
 
   // setting all the distances initially to INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
@@ -232,8 +232,8 @@ const DijkstraResult Graph<T>::dijkstra_deterministic(
 
     // for all the reachable vertex from the currently exploring vertex
     // we will try to minimize the distance
-    if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-      for (const auto& elem : cachedAdjMatrix->at(currentNode)) {
+    if (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
         // minimizing distances
         if (elem.second->isWeighted().has_value() &&
             elem.second->isWeighted().value()) {
@@ -325,7 +325,7 @@ const DijkstraResult Graph<T>::dijkstra_deterministic2(
   }
   // n denotes the number of vertices in graph
   // unused
-  // auto n = cachedAdjMatrix->size();
+  // auto n = cachedAdjMatrixOut->size();
 
   // setting all the distances initially to INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
@@ -388,8 +388,8 @@ const DijkstraResult Graph<T>::dijkstra_deterministic2(
 
     // for all the reachable vertex from the currently exploring vertex
     // we will try to minimize the distance
-    if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-      for (const auto& elem : cachedAdjMatrix->at(currentNode)) {
+    if (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
         // minimizing distances
         if (elem.second->isWeighted().has_value() &&
             elem.second->isWeighted().value()) {
@@ -481,7 +481,7 @@ const DijkstraResult Graph<T>::criticalpath_deterministic(
   }
   // n denotes the number of vertices in graph
   // unused
-  // auto n = cachedAdjMatrix->size();
+  // auto n = cachedAdjMatrixOut->size();
 
   // setting all the distances initially to -INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
@@ -536,8 +536,8 @@ const DijkstraResult Graph<T>::criticalpath_deterministic(
 
     // for all the reachable vertex from the currently exploring vertex
     // we will try to minimize the distance
-    if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-      for (const auto& elem : cachedAdjMatrix->at(currentNode)) {
+    if (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
         // minimizing distances
         if (elem.second->isWeighted().has_value() &&
             elem.second->isWeighted().value()) {
diff --git a/include/CXXGraph/Graph/Algorithm/HopcroftKarp_impl.hpp b/include/CXXGraph/Graph/Algorithm/HopcroftKarp_impl.hpp
@@ -74,7 +74,7 @@ namespace CXXGraph {
                     auto current = queue.front();
                     queue.pop();
 
-                    auto neighbors = this->inOutNeighbors(current);
+                    auto neighbors = this->inOrOutNeighbors(current);
                     for(const auto& neighbor : neighbors) {
                         if(color.find(neighbor->getUserId()) == color.end()) {
                             // assign opposite color
@@ -180,7 +180,7 @@ namespace CXXGraph {
                 // stop if shortest path already found
                 if (path_len != -1 && dist.at(u) >= path_len) continue;
 
-                auto neighbors = this->inOutNeighbors(u);
+                auto neighbors = this->inOrOutNeighbors(u);
                 for (const auto& v : neighbors) {
                     if (match.find(v) == match.end()) {
                         // found unmatched node - augmenting path exists
@@ -202,7 +202,7 @@ namespace CXXGraph {
         auto dfs = [&](auto&& self, shared<const Node<T>> u) -> bool {
             if (dist.find(u) == dist.end()) return false;
 
-            auto neighbors = this->inOutNeighbors(u);
+            auto neighbors = this->inOrOutNeighbors(u);
             for (const auto& v : neighbors) {
                 if (match.find(v) == match.end()) {
                     // found unmatched node at correct distance
diff --git a/include/CXXGraph/Graph/Algorithm/Kahn_impl.hpp b/include/CXXGraph/Graph/Algorithm/Kahn_impl.hpp
@@ -35,13 +35,13 @@ TopoSortResult<T> Graph<T>::kahn() const {
     return result;
   } else {
     const auto nodeSet = Graph<T>::getNodeSet();
-    result.nodesInTopoOrder.reserve(cachedAdjMatrix->size());
+    result.nodesInTopoOrder.reserve(cachedAdjMatrixOut->size());
 
     std::unordered_map<CXXGraph::id_t, unsigned int> indegree;
     for (const auto &node : nodeSet) {
       indegree[node->getId()] = 0;
     }
-    for (const auto &list : *cachedAdjMatrix) {
+    for (const auto &list : *cachedAdjMatrixOut) {
       auto children = list.second;
       for (const auto &child : children) {
         indegree[std::get<0>(child)->getId()]++;
@@ -62,8 +62,8 @@ TopoSortResult<T> Graph<T>::kahn() const {
       topologicalOrder.pop();
       result.nodesInTopoOrder.push_back(*currentNode);
 
-      if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-        for (const auto &child : cachedAdjMatrix->at(currentNode)) {
+      if (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+        for (const auto &child : cachedAdjMatrixOut->at(currentNode)) {
           if (--indegree[std::get<0>(child)->getId()] == 0) {
             topologicalOrder.emplace(std::get<0>(child));
           }
diff --git a/include/CXXGraph/Graph/Algorithm/Kosaraju_impl.hpp b/include/CXXGraph/Graph/Algorithm/Kosaraju_impl.hpp
@@ -51,9 +51,9 @@ SCCResult<T> Graph<T>::kosaraju() const {
           visited[source->getId()] = true;
 
           // travel the neighbors
-          for (size_t i = 0; i < (*cachedAdjMatrix)[source].size(); i++) {
+          for (size_t i = 0; i < (*cachedAdjMatrixOut)[source].size(); i++) {
             shared<const Node<T>> neighbor =
-                (*cachedAdjMatrix)[source].at(i).first;
+                (*cachedAdjMatrixOut)[source].at(i).first;
             if (visited[neighbor->getId()] == false) {
               // make recursive call from neighbor
               dfs_helper(neighbor);
diff --git a/include/CXXGraph/Graph/Algorithm/Prim_impl.hpp b/include/CXXGraph/Graph/Algorithm/Prim_impl.hpp
@@ -46,7 +46,7 @@ const MstResult Graph<T>::prim() const {
 
   // setting all the distances initially to INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
-  for (const auto &elem : (*cachedAdjMatrix)) {
+  for (const auto &elem : (*cachedAdjMatrixOut)) {
     dist[elem.first] = INF_DOUBLE;
   }
 
@@ -83,8 +83,8 @@ const MstResult Graph<T>::prim() const {
     pq.pop();
     // for all the reachable vertex from the currently exploring vertex
     // we will try to minimize the distance
-    if (cachedAdjMatrix->find(currentNode) != cachedAdjMatrix->end()) {
-      for (const auto &elem : cachedAdjMatrix->at(currentNode)) {
+    if (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
+      for (const auto &elem : cachedAdjMatrixOut->at(currentNode)) {
         // minimizing distances
         if (elem.second->isWeighted().has_value() &&
             elem.second->isWeighted().value()) {
diff --git a/include/CXXGraph/Graph/Algorithm/Tarjan_impl.hpp b/include/CXXGraph/Graph/Algorithm/Tarjan_impl.hpp
@@ -81,12 +81,12 @@ const TarjanResult<T> Graph<T>::tarjan(const unsigned int typeMask) const {
           vbccNodeStack.emplace(*curNode);
         }
         // travel the neighbors
-        if (cachedAdjMatrix->find(curNode) != cachedAdjMatrix->end()) {
+        if (cachedAdjMatrixOut->find(curNode) != cachedAdjMatrixOut->end()) {
           int numSon = 0;
           bool nodeIsAdded =
               false;  // whether a node has been marked as a cut vertice
           for (const auto &[neighborNode, edge] :
-               cachedAdjMatrix->at(curNode)) {
+               cachedAdjMatrixOut->at(curNode)) {
             if (!discoveryTime.count(neighborNode->getId())) {
               dfs_helper(neighborNode, edge);
               lowestDisc[curNode->getId()] =
diff --git a/include/CXXGraph/Graph/Algorithm/TopologicalSort_impl.hpp b/include/CXXGraph/Graph/Algorithm/TopologicalSort_impl.hpp
@@ -46,8 +46,8 @@ TopoSortResult<T> Graph<T>::topologicalSort() const {
          &result](shared<const Node<T>> curNode) {
           visited[curNode] = true;
 
-          if (cachedAdjMatrix->find(curNode) != cachedAdjMatrix->end()) {
-            for (const auto &edge : cachedAdjMatrix->at(curNode)) {
+          if (cachedAdjMatrixOut->find(curNode) != cachedAdjMatrixOut->end()) {
+            for (const auto &edge : cachedAdjMatrixOut->at(curNode)) {
               const auto &nextNode = edge.first;
               if (false == visited[nextNode]) {
                 postorder_helper(nextNode);
@@ -58,7 +58,7 @@ TopoSortResult<T> Graph<T>::topologicalSort() const {
           result.nodesInTopoOrder.push_back(*curNode);
         };
 
-    auto numNodes = cachedAdjMatrix->size();
+    auto numNodes = cachedAdjMatrixOut->size();
     result.nodesInTopoOrder.reserve(numNodes);
 
     for (const auto &node : nodeSet) {
diff --git a/include/CXXGraph/Graph/Algorithm/welshPowellColoring_impl.hpp b/include/CXXGraph/Graph/Algorithm/welshPowellColoring_impl.hpp
@@ -12,7 +12,7 @@
 namespace CXXGraph {
 template <typename T>
 std::map<Node<T>, int> Graph<T>::welshPowellColoring() const {
-  auto adjMatrix = *getAdjMatrix();
+  auto adjMatrix = *getAdjMatrixOut();
 
   std::vector<std::pair<std::shared_ptr<const Node<T>>, int>>
       degreeOfVertexVector = {};
diff --git a/include/CXXGraph/Graph/Graph_decl.h b/include/CXXGraph/Graph/Graph_decl.h
diff --git a/include/CXXGraph/Graph/Graph_impl.hpp b/include/CXXGraph/Graph/Graph_impl.hpp
diff --git a/test/DirectedEdgeTest.cpp b/test/DirectedEdgeTest.cpp
diff --git a/test/EdgeTest.cpp b/test/EdgeTest.cpp
diff --git a/test/GraphTest.cpp b/test/GraphTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ static void getAdjMatrixX(benchmark::State &state) {`
`122`	`122`	`g.addEdge(&(*e.second));`
`123`	`123`	`}`
`124`	`124`	`for (auto _ : state) {`
`125`		`- auto adjMatrix = g.getAdjMatrix();`
	`125`	`+ auto adjMatrix = g.getAdjMatrixOut();`
`126`	`126`	`}`
`127`	`127`	`state.SetComplexityN(2);`
`128`	`128`	`}`
`@@ -134,7 +134,7 @@ BENCHMARK(getAdjMatrixX)`
`134`	`134`
`135`	`135`	`static void getAdjMatrixCitHep(benchmark::State &state) {`
`136`	`136`	`for (auto _ : state) {`
`137`		`- auto adjMatrix = cit_graph_ptr->getAdjMatrix();`
	`137`	`+ auto adjMatrix = cit_graph_ptr->getAdjMatrixOut();`
`138`	`138`	`}`
`139`	`139`	`state.SetComplexityN(2);`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ const std::vector<Node<T>> Graph<T>::depth_first_search(`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`	`};`
`60`		`- explore(cachedAdjMatrix, *start_node_it, visited);`
	`60`	`+ explore(cachedAdjMatrixOut, *start_node_it, visited);`
`61`	`61`
`62`	`62`	`return visited;`
`63`	`63`	`}`