Feature getters for set of neighbors (#318)

* Remove static_cast of 0 to template type T in best_first_search

* Change all the raw pointers in the library to smart pointers

* Rewrite tests to use smart pointers

* Finish converting tests to smart pointers

* Add setter for nodes in Edge nodePair

* Fix addition of edges and construction of adjacency matrix

* Add overloads of algorithms which take raw pointers to mantain interface

* Fix typos in tests

* Change dynamic_casts into dynamic_pointer_casts

* Decrease the number of random edges and nodes in RW and partition tests

* Add out/inOutEdges convenience methods for Graph

* Add tests for the out/inOutEdges methods

* Add overload of equality operators and hash functions for pointers of nodes

* Implement new hash functions for pointers of nodes and edges

* Increase number of nodes and edges in partition and RW tests

* Fix typo

* Use shared pointers in random node/edge generators

* Convert pointers in TransitiveReductionTest.cpp

* Add overload of addEdge for raw pointers

* Fix typo

* Fix edge insertion in FloydWarshall benchmark

* Fix typo in benchmark

* Remove all the calls to new in the tests

* Fix typo in benchmark FloydWarshall

Fix typo in benchmark FloydWarshall

* Conversion of example codes

* Formatting

* Add test for overloads of out/inOutEdges

* Change name of out/inOutEdges methods to out/inOutNeighbors

---------

Co-authored-by: sbaldu <[email protected]>

Author: sbaldu

include/Graph/Graph.hpp

@@ -60,6 +60,7 @@
 #include "Partitioning/Utility/Globals.hpp"
 #include "Utility/ConstString.hpp"
 #include "Utility/ConstValue.hpp"
+#include "Utility/PointerHash.hpp"
 #include "Utility/Reader.hpp"
 #include "Utility/ThreadSafe.hpp"
 #include "Utility/Typedef.hpp"
@@ -209,7 +210,8 @@ class Graph {
    * @returns a list of Nodes of the graph
    *
    */
-  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>> getNodeSet() const;
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+  getNodeSet() const;
   /**
    * \brief
    * Function that sets the data contained in a node
@@ -244,6 +246,47 @@ class Graph {
    * corrispondent to the link Note: No Thread Safe
    */
   virtual const std::shared_ptr<AdjacencyMatrix<T>> getAdjMatrix() const;
+  /**
+   * \brief This function generates a set of nodes linked to the provided node in a
+   * directed graph
+   * Note: No Thread Safe
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>> outNeighbors(
+      const Node<T> *node) const;
+  /**
+   * \brief This function generates a set of nodes linked to the provided node in a
+   * directed graph
+   * Note: No Thread Safe
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>> outNeighbors(
+      shared<const Node<T>> node) const;
+  /**
+   * \brief This function generates a set of nodes linked to the provided node in
+   * any graph
+   * Note: No Thread Safe
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+  inOutNeighbors(const Node<T> *node) const;
+  /**
+   * \brief
+   * \brief This function generates a set of nodes linked to the provided node in
+   * any graph
+   * Note: No Thread Safe
+   *
+   * @param Pointer to the node
+   *
+   */
+  virtual const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+  inOutNeighbors(shared<const Node<T>> node) const;
   /**
    * @brief This function finds the subset of given a nodeId
    * Subset is stored in a map where keys are the hash-id of the node & values
@@ -261,7 +304,8 @@ class Graph {
    * @brief This function finds the subset of given a nodeId
    * Subset is stored in a map where keys are the hash-id of the node & values
    * is the subset.
-   * @param shared pointer to subset query subset, we want to find target in this subset
+   * @param shared pointer to subset query subset, we want to find target in
+   * this subset
    * @param elem elem that we wish to find in the subset
    *
    * @return parent node of elem
@@ -744,7 +788,8 @@ bool Graph<T>::findEdge(shared<const Node<T>> v1, shared<const Node<T>> v2,
 }
 
 template <typename T>
-const std::unordered_set<shared<const Node<T>>, nodeHash<T>> Graph<T>::getNodeSet() const {
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+Graph<T>::getNodeSet() const {
   std::unordered_set<shared<const Node<T>>, nodeHash<T>> nodeSet;
   for (const auto &edgeSetIt : edgeSet) {
     nodeSet.insert(edgeSetIt->getNodePair().first);
@@ -863,11 +908,11 @@ int Graph<T>::writeToDot(const std::string &workingDir,
     }
     if (edgePtr->isWeighted().has_value() && edgePtr->isWeighted().value()) {
       // Weights in dot files must be integers
-      edgeLine +=
-          " [weight=" +
-          std::to_string(static_cast<int>(
-              std::dynamic_pointer_cast<const Weighted>(edgePtr)->getWeight())) +
-          ']';
+      edgeLine += " [weight=" +
+                  std::to_string(static_cast<int>(
+                      std::dynamic_pointer_cast<const Weighted>(edgePtr)
+                          ->getWeight())) +
+                  ']';
     }
     edgeLine += ";\n";
     ofileGraph << edgeLine;
@@ -917,7 +962,8 @@ void Graph<T>::writeGraphToStream(std::ostream &oGraph, std::ostream &oNodeFeat,
       oEdgeWeight
           << edge->getId() << sep
           << (edge->isWeighted().has_value() && edge->isWeighted().value()
-                  ? (std::dynamic_pointer_cast<const Weighted>(edge))->getWeight()
+                  ? (std::dynamic_pointer_cast<const Weighted>(edge))
+                        ->getWeight()
                   : 0.0)
           << sep
           << (edge->isWeighted().has_value() && edge->isWeighted().value() ? 1
@@ -1179,7 +1225,8 @@ template <typename T>
 unsigned long long Graph<T>::setFind(
     std::unordered_map<unsigned long long, Subset> *subsets,
     const unsigned long long nodeId) const {
-  auto subsets_ptr = make_shared<std::unordered_map<unsigned long long, Subset>>(*subsets);
+  auto subsets_ptr =
+      make_shared<std::unordered_map<unsigned long long, Subset>>(*subsets);
   // find root and make root as parent of i
   // (path compression)
   if ((*subsets)[nodeId].parent != nodeId) {
@@ -1205,18 +1252,21 @@ unsigned long long Graph<T>::setFind(
 }
 
 template <typename T>
-void Graph<T>::setUnion(
-    std::unordered_map<unsigned long long, Subset> *subsets,
-    const unsigned long long elem1, const unsigned long long elem2) const {
-  /* auto subsets_ptr = make_shared<std::unordered_map<unsigned long long, Subset>>(*subsets); */
+void Graph<T>::setUnion(std::unordered_map<unsigned long long, Subset> *subsets,
+                        const unsigned long long elem1,
+                        const unsigned long long elem2) const {
+  /* auto subsets_ptr = make_shared<std::unordered_map<unsigned long long,
+   * Subset>>(*subsets); */
   // if both sets have same parent
   // then there's nothing to be done
-  /* if ((*subsets_ptr)[elem1].parent == (*subsets_ptr)[elem2].parent) return; */
+  /* if ((*subsets_ptr)[elem1].parent == (*subsets_ptr)[elem2].parent) return;
+   */
   /* auto elem1Parent = Graph<T>::setFind(subsets_ptr, elem1); */
   /* auto elem2Parent = Graph<T>::setFind(subsets_ptr, elem2); */
   /* if ((*subsets_ptr)[elem1Parent].rank < (*subsets_ptr)[elem2Parent].rank) */
   /*   (*subsets_ptr)[elem1].parent = elem2Parent; */
-  /* else if ((*subsets_ptr)[elem1Parent].rank > (*subsets_ptr)[elem2Parent].rank) */
+  /* else if ((*subsets_ptr)[elem1Parent].rank >
+   * (*subsets_ptr)[elem2Parent].rank) */
   /*   (*subsets_ptr)[elem2].parent = elem1Parent; */
   /* else { */
   /*   (*subsets_ptr)[elem2].parent = elem1Parent; */
@@ -1329,6 +1379,59 @@ const std::shared_ptr<AdjacencyMatrix<T>> Graph<T>::getAdjMatrix() const {
   return adj;
 }
 
+template <typename T>
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>> Graph<T>::outNeighbors(
+    const Node<T> *node) const {
+  auto node_shared = make_shared<const Node<T>>(*node);
+
+  return outNeighbors(node_shared);
+}
+
+template <typename T>
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>> Graph<T>::outNeighbors(
+    shared<const Node<T>> node) const {
+  auto adj = getAdjMatrix();
+  if (adj->find(node) == adj->end()) {
+    return std::unordered_set<shared<const Node<T>>, nodeHash<T>>();
+  }
+  auto nodeEdgePairs = adj->at(node);
+
+  std::unordered_set<shared<const Node<T>>, nodeHash<T>> outNeighbors;
+  for (auto pair : nodeEdgePairs) {
+    if (pair.second->isDirected().has_value() &&
+        pair.second->isDirected().value()) {
+      outNeighbors.insert(pair.first);
+    }
+  }
+
+  return outNeighbors;
+}
+
+template <typename T>
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+Graph<T>::inOutNeighbors(const Node<T> *node) const {
+  auto node_shared = make_shared<const Node<T>>(*node);
+
+  return inOutNeighbors(node_shared);
+}
+
+template <typename T>
+const std::unordered_set<shared<const Node<T>>, nodeHash<T>>
+Graph<T>::inOutNeighbors(shared<const Node<T>> node) const {
+  auto adj = Graph<T>::getAdjMatrix();
+  if (adj->find(node) == adj->end()) {
+    return std::unordered_set<shared<const Node<T>>, nodeHash<T>>();
+  }
+  auto nodeEdgePairs = adj->at(node);
+
+  std::unordered_set<shared<const Node<T>>, nodeHash<T>> inOutNeighbors;
+  for (auto pair : nodeEdgePairs) {
+    inOutNeighbors.insert(pair.first);
+  }
+
+  return inOutNeighbors;
+}
+
 template <typename T>
 const DijkstraResult Graph<T>::dijkstra(const Node<T> &source,
                                         const Node<T> &target) const {
@@ -1466,7 +1569,8 @@ const BellmanFordResult Graph<T>::bellmanford(const Node<T> &source,
     return result;
   }
   // setting all the distances initially to INF_DOUBLE
-  std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist, currentDist;
+  std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist,
+      currentDist;
   // n denotes the number of vertices in graph
   auto n = nodeSet.size();
   for (const auto &elem : nodeSet) {
@@ -1555,7 +1659,8 @@ const Graph<T> Graph<T>::transitiveReduction() const {
   Graph<T> result(this->edgeSet);
 
   unsigned long long edgeId = 0;
-  std::unordered_set<shared<const Node<T>>, nodeHash<T>> nodes = this->getNodeSet();
+  std::unordered_set<shared<const Node<T>>, nodeHash<T>> nodes =
+      this->getNodeSet();
   for (auto x : nodes) {
     for (auto y : nodes) {
       if (this->findEdge(x, y, edgeId)) {
@@ -1849,7 +1954,8 @@ const MstResult Graph<T>::kruskal() const {
       sortedEdges;
   for (const auto &edge : edgeSet) {
     if (edge->isWeighted().has_value() && edge->isWeighted().value()) {
-      auto weight = (std::dynamic_pointer_cast<const Weighted>(edge))->getWeight();
+      auto weight =
+          (std::dynamic_pointer_cast<const Weighted>(edge))->getWeight();
       sortedEdges.push(std::make_pair(weight, edge));
     } else {
       // No Weighted Edge
@@ -2838,8 +2944,12 @@ double Graph<T>::fordFulkersonMaxFlow(const Node<T> &source,
     return -1;
   }
   double maxFlow = 0;
-  std::unordered_map<shared<const Node<T>>, shared<const Node<T>>, nodeHash<T>> parent;
-  std::unordered_map<shared<const Node<T>>, std::unordered_map<shared<const Node<T>>, double, nodeHash<T>>, nodeHash<T>>
+  std::unordered_map<shared<const Node<T>>, shared<const Node<T>>, nodeHash<T>>
+      parent;
+  std::unordered_map<
+      shared<const Node<T>>,
+      std::unordered_map<shared<const Node<T>>, double, nodeHash<T>>,
+      nodeHash<T>>
       weightMap;
   // build weight map
   auto edgeSet = this->getEdgeSet();