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

Author: brghash

benchmark/Graph_BM.cpp

@@ -122,7 +122,7 @@ static void getAdjMatrixX(benchmark::State &state) {
     g.addEdge(&(*e.second));
   }
   for (auto _ : state) {
-    auto adjMatrix = g.getAdjMatrixOut();
+    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->getAdjMatrixOut();
+    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 (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
-      for (const auto &elem : cachedAdjMatrixOut->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 (cachedAdjMatrixOut->count(level_tracker[i])) {
-            for (const auto &elem : cachedAdjMatrixOut->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 (cachedAdjMatrixOut->find(node) != cachedAdjMatrixOut->end()) {
-      for (const auto &elem : cachedAdjMatrixOut->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/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 < (*cachedAdjMatrixOut)[source].size(); i++) {
+          for (size_t i = 0; i < (*cachedAdjListOut)[source].size(); i++) {
             shared<const Node<T>> neighbor =
-                (*cachedAdjMatrixOut)[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 < (*cachedAdjMatrixOut)[source].size(); i++) {
+            for (size_t i = 0; i < (*cachedAdjListOut)[source].size(); i++) {
               shared<const Node<T>> neighbor =
-                  (*cachedAdjMatrixOut)[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(cachedAdjMatrixOut, 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 : (*cachedAdjMatrixOut)) {
+  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 = cachedAdjMatrixOut->find(solved);
-    if (it != cachedAdjMatrixOut->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(cachedAdjMatrixOut, *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 : (*cachedAdjMatrixOut)[u]) {
+    for (const auto &i : (*cachedAdjListOut)[u]) {
       auto v = i.first;
       int weight = 0;
       if (i.second->isWeighted().has_value() &&

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 = cachedAdjMatrixOut->size();
+  // auto n = cachedAdjListOut->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 (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
-      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
+    if (cachedAdjListOut->find(currentNode) != cachedAdjListOut->end()) {
+      for (const auto& elem : cachedAdjListOut->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 = cachedAdjMatrixOut->size();
+  // auto n = cachedAdjListOut->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 (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
-      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
+    if (cachedAdjListOut->find(currentNode) != cachedAdjListOut->end()) {
+      for (const auto& elem : cachedAdjListOut->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 = cachedAdjMatrixOut->size();
+  // auto n = cachedAdjListOut->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 (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
-      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
+    if (cachedAdjListOut->find(currentNode) != cachedAdjListOut->end()) {
+      for (const auto& elem : cachedAdjListOut->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 = cachedAdjMatrixOut->size();
+  // auto n = cachedAdjListOut->size();
 
   // setting all the distances initially to -INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
@@ -513,8 +513,7 @@ const DijkstraResult Graph<T>::criticalpath_deterministic(
     };
   };
 
-  std::priority_queue<VertexInfo, std::vector<VertexInfo>, VertexInfoLesser>
-      pq;
+  std::priority_queue<VertexInfo, std::vector<VertexInfo>, VertexInfoLesser> pq;
 
   // pushing the source vertex 's' with 0 distance in min heap
   pq.push(VertexInfo{0.0, stableIds[*source_node_it], *source_node_it});
@@ -536,8 +535,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 (cachedAdjMatrixOut->find(currentNode) != cachedAdjMatrixOut->end()) {
-      for (const auto& elem : cachedAdjMatrixOut->at(currentNode)) {
+    if (cachedAdjListOut->find(currentNode) != cachedAdjListOut->end()) {
+      for (const auto& elem : cachedAdjListOut->at(currentNode)) {
         // minimizing distances
         if (elem.second->isWeighted().has_value() &&
             elem.second->isWeighted().value()) {