Caching Adjacency Matrix for faster edge lookup

include/Graph/Graph.hpp

@@ -101,6 +101,8 @@
  private:
   T_EdgeSet<T> edgeSet = {};
 
+  shared<AdjacencyMatrix<T>> cachedAdjMatrix;
+
   // Private non-const getter for the set of nodes
   std::unordered_set<shared<Node<T>>, nodeHash<T>> nodeSet();
 
@@ -130,7 +132,7 @@
 #endif
 
  public:
-  Graph() = default;
+  Graph();
   Graph(const T_EdgeSet<T> &edgeSet);
   virtual ~Graph() = default;
   /**
@@ -248,7 +250,9 @@
    * corrispondent to the link
    * Note: No Thread Safe
    */
-  virtual const std::shared_ptr<AdjacencyMatrix<T>> getAdjMatrix() const;
+  virtual shared<AdjacencyMatrix<T>> getAdjMatrix() const;
+
+  virtual void cacheAdjMatrix();
   /**
    * \brief This function generates a set of nodes linked to the provided node
    * in a directed graph
@@ -733,11 +737,19 @@
                                      const AdjacencyMatrix<T> &adj);
 };
 
+template <typename T>
+Graph<T>::Graph() {
+  /* Caching the adjacency matrix */
+  cacheAdjMatrix();
+}
+
 template <typename T>
 Graph<T>::Graph(const T_EdgeSet<T> &edgeSet) {
   for (auto edgeIt : edgeSet) {
     this->edgeSet.insert(edgeIt);
   }
+  /* Caching the adjacency matrix */
+  cacheAdjMatrix();
 }
 
 template <typename T>
@@ -751,6 +763,8 @@
   for (auto edgeIt : edgeSet) {
     this->edgeSet.insert(edgeIt);
   }
+  /* Caching the adjacency matrix */
+  cacheAdjMatrix();
 }
 
 template <typename T>
@@ -759,24 +773,47 @@
     if (edge->isWeighted().has_value() && edge->isWeighted().value()) {
       auto edge_shared = make_shared<DirectedWeightedEdge<T>>(*edge);
       this->edgeSet.insert(edge_shared);
+      std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem = {edge_shared->getNodePair().second, edge_shared};
+      (*cachedAdjMatrix)[edge_shared->getNodePair().first].push_back(std::move(elem));
     } else {
       auto edge_shared = make_shared<DirectedEdge<T>>(*edge);
       this->edgeSet.insert(edge_shared);
+      std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem = {edge_shared->getNodePair().second, edge_shared};
+      (*cachedAdjMatrix)[edge_shared->getNodePair().first].push_back(std::move(elem));
     }
   } else {
     if (edge->isWeighted().has_value() && edge->isWeighted().value()) {
       auto edge_shared = make_shared<UndirectedWeightedEdge<T>>(*edge);
       this->edgeSet.insert(edge_shared);
+      std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem = {edge_shared->getNodePair().second, edge_shared};
+      (*cachedAdjMatrix)[edge_shared->getNodePair().first].push_back(std::move(elem));
+      std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem1 = {edge_shared->getNodePair().first, edge_shared};
+      (*cachedAdjMatrix)[edge_shared->getNodePair().second].push_back(std::move(elem1));
     } else {
       auto edge_shared = make_shared<UndirectedEdge<T>>(*edge);
       this->edgeSet.insert(edge_shared);
+      std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem = {edge_shared->getNodePair().second, edge_shared};
+      (*cachedAdjMatrix)[edge_shared->getNodePair().first].push_back(std::move(elem));
+      std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem1 = {edge_shared->getNodePair().first, edge_shared};
+      (*cachedAdjMatrix)[edge_shared->getNodePair().second].push_back(std::move(elem1));
     }
   }
 }
 
 template <typename T>
 void Graph<T>::addEdge(shared<const Edge<T>> edge) {
   this->edgeSet.insert(edge);
+  /* Adding new edge in cached adjacency matrix */
+  if(edge.get()->isDirected().has_value() && edge.get()->isDirected().value()){
+    std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem = {edge.get()->getNodePair().second, edge};
+    (*cachedAdjMatrix)[edge.get()->getNodePair().first].push_back(std::move(elem));
+  }
+  else{
+    std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem = {edge.get()->getNodePair().second, edge};
+    (*cachedAdjMatrix)[edge.get()->getNodePair().first].push_back(std::move(elem));
+    std::pair<shared<const Node<T>>, shared<const Edge<T>>> elem1 = {edge.get()->getNodePair().first, edge};
+    (*cachedAdjMatrix)[edge.get()->getNodePair().second].push_back(std::move(elem1));
+  }
 }
 
 template <typename T>
@@ -788,6 +825,32 @@
     [edgeOpt](const Edge<T> *edge) { return (*(edgeOpt.value()) == *edge); }));
     */
     edgeSet.erase(edgeSet.find(edgeOpt.value()));
+    int delIndex = -1;
+    int i = 0;
+    /* Removing the edge from the cached adjacency matrix */
+    for(auto elem : (*cachedAdjMatrix)[edgeOpt.value().get()->getNodePair().first]){
+      if(elem.second.get()->getId() == edgeId){
+        delIndex = i;
+        break;
+      }
+      i++;
+    }
+    if(delIndex != -1){
+      (*cachedAdjMatrix)[edgeOpt.value().get()->getNodePair().first].erase((*cachedAdjMatrix)[edgeOpt.value().get()->getNodePair().first].begin()+delIndex);
+    }
+
+    delIndex = -1;
+    i = 0;
+    for(auto elem : (*cachedAdjMatrix)[edgeOpt.value().get()->getNodePair().second]){
+      if(elem.second.get()->getId() == edgeId){
+        delIndex = i;
+        break;
+      }
+      i++;
+    }
+    if(delIndex != -1){
+      (*cachedAdjMatrix)[edgeOpt.value().get()->getNodePair().second].erase((*cachedAdjMatrix)[edgeOpt.value().get()->getNodePair().second].begin()+delIndex);
+    }
   }
 }
 
@@ -805,7 +868,32 @@
                         unsigned long long &id) const {
   // This could be made faster by looking for the edge hash, assuming we hash
   // based on node data, instead of a unique integer
-  for (auto e : this->edgeSet) {
+  if(cachedAdjMatrix.get() != NULL && cachedAdjMatrix->size() != 0){
+    /* Searching for the edge using cached adjacency matrix */
+
+    for(auto elem : (*cachedAdjMatrix)[v1]){
+      if(elem.first == v2){
+        id = elem.second.get()->getId();
+        return true;
+      }
+    }
+  }
+  else{
+    /* Searching for the edge using edgeset */
+
+    for (auto e : this->edgeSet) {
+      if ((e->getNodePair().first == v1) && (e->getNodePair().second == v2)) {
+        id = e->getId();
+        return true;
+      }
+      if (!e->isDirected() &&
+          ((e->getNodePair().second == v1) && (e->getNodePair().first == v2))) {
+        id = e->getId();
+        return true;
+      }
+    }
+  }
+  /*for (auto e : this->edgeSet) {
     if ((e->getNodePair().first == v1) && (e->getNodePair().second == v2)) {
       id = e->getId();
       return true;
@@ -815,7 +903,7 @@
       id = e->getId();
       return true;
     }
-  }
+  }*/
 
   id = 0;
   return false;
@@ -1381,7 +1469,7 @@
 }
 
 template <typename T>
-const std::shared_ptr<AdjacencyMatrix<T>> Graph<T>::getAdjMatrix() const {
+shared<AdjacencyMatrix<T>> Graph<T>::getAdjMatrix() const {
   auto adj = std::make_shared<AdjacencyMatrix<T>>();
   auto addElementToAdjMatrix = [&adj](shared<const Node<T>> nodeFrom,
                                       shared<const Node<T>> nodeTo,
@@ -1413,6 +1501,12 @@
   return adj;
 }
 
+template <typename T>
+void Graph<T>::cacheAdjMatrix() {
+  const auto adj = Graph<T>::getAdjMatrix();
+  this->cachedAdjMatrix = adj;
+}
+
 template <typename T>
 const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
 Graph<T>::outNeighbors(const Node<T> *node) const {

test/GraphTest.cpp

@@ -105,6 +105,54 @@ TEST(GraphTest, GetNodeSet_2) {
               }) != nodeSet.end());
 }
 
+TEST(GraphTest, FindEdge_Test) {
+  CXXGraph::Node<int> node1("1", 1);
+  CXXGraph::Node<int> node2("2", 2);
+  CXXGraph::Node<int> node3("3", 3);
+  CXXGraph::Node<int> node4("4", 2);
+  CXXGraph::Node<int> node5("5", 3);
+  CXXGraph::UndirectedEdge<int> edge(1, node1, node2);
+  CXXGraph::UndirectedEdge<int> edge2(2, node2, node3);
+  CXXGraph::T_EdgeSet<int> edgeSet;
+
+  /* adding edges to the edgeset */
+
+  edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge));
+  edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge2));
+  CXXGraph::Graph<int> graph(edgeSet);
+  unsigned long long edgeId = 0;
+  ASSERT_TRUE(graph.findEdge(&node1,&node2,edgeId));
+  CXXGraph::UndirectedEdge<int> edge3(3, node1, node3);
+
+  /* adding edge using addEdge() */
+
+  graph.addEdge(make_shared<CXXGraph::UndirectedEdge<int>>(edge3));
+  ASSERT_TRUE(graph.findEdge(&node1,&node3,edgeId));
+  ASSERT_TRUE(graph.findEdge(&node3,&node1,edgeId));
+  CXXGraph::DirectedEdge<int> edge4(4, node1, node5);
+  graph.addEdge(make_shared<CXXGraph::DirectedEdge<int>>(edge4));
+  ASSERT_TRUE(graph.findEdge(&node1,&node5,edgeId));
+  ASSERT_FALSE(graph.findEdge(&node5,&node1,edgeId));
+
+  /* removing edge using removeEdge() */
+
+  graph.removeEdge(2);
+  CXXGraph::UndirectedWeightedEdge<int> edge5(7, node4, node5, 5);
+  CXXGraph::DirectedWeightedEdge<int> edge6(8, node2, node5, 10);
+
+  /* adding edge using addEdge() */
+
+  graph.addEdge(&edge5);
+  graph.addEdge(&edge6);
+  ASSERT_FALSE(graph.findEdge(&node2,&node3,edgeId));
+  ASSERT_FALSE(graph.findEdge(&node3,&node2,edgeId));
+
+  /* Test for empty graph */
+
+  CXXGraph::Graph<int> graph2;
+  ASSERT_FALSE(graph2.findEdge(&node2,&node3,edgeId));
+}
+
 TEST(GraphTest, RawAddEdge_1) {
   CXXGraph::Node<int> n1("a", 1);
   CXXGraph::Node<int> n2("b", 1);