Formatted relevant files to pass clang-format checks

ZigRazor · Oct 2, 2024 · 0521f2b · 0521f2b
1 parent 4acdb1a
commit 0521f2b
Show file tree

Hide file tree

Showing 8 changed files with 124 additions and 91 deletions.
diff --git a/include/CXXGraph/Graph/Algorithm/BestFirstSearch_impl.hpp b/include/CXXGraph/Graph/Algorithm/BestFirstSearch_impl.hpp
@@ -22,12 +22,12 @@
 
 #pragma once
 
+#include <algorithm>
 #include <atomic>
 #include <condition_variable>
 #include <mutex>
 #include <queue>
 #include <thread>
-#include <algorithm>
 
 #include "CXXGraph/Graph/Graph_decl.h"
 

diff --git a/include/CXXGraph/Graph/Algorithm/BronKerbosch_impl.hpp b/include/CXXGraph/Graph/Algorithm/BronKerbosch_impl.hpp
@@ -27,45 +27,49 @@
 namespace CXXGraph {
 
 template <typename T>
-const BronKerboschResult<T> Graph<T>::bron_kerbosch() const{
+const BronKerboschResult<T> Graph<T>::bron_kerbosch() const {
   std::vector<T_NodeSet<T>> maximalCliques{};
   BronKerboschResult<T> result;
 
-  if(!isUndirectedGraph()){
+  if (!isUndirectedGraph()) {
     result.success = false;
     result.errorMessage = ERR_DIR_GRAPH;
     return result;
   }
 
   T_NodeSet<T> _X, _R, _P(getNodeSet());
-
 
-  std::function<void(T_NodeSet<T>,T_NodeSet<T>,T_NodeSet<T>)> rec = [&maximalCliques,&rec,this]
-    (T_NodeSet<T> R, T_NodeSet<T> P, T_NodeSet<T> X){
-      if(P.empty() && X.empty()){
-        maximalCliques.push_back(R);
-      }
+  std::function<void(T_NodeSet<T>, T_NodeSet<T>, T_NodeSet<T>)> rec =
+      [&maximalCliques, &rec, this](T_NodeSet<T> R, T_NodeSet<T> P,
+                                    T_NodeSet<T> X) {
+        if (P.empty() && X.empty()) {
+          maximalCliques.push_back(R);
+        }
 
-      auto it = P.begin();
-      while(it != P.end()){
-        const auto v = *it;
-        T_NodeSet<T> X2, R2(R), P2, nbd(inOutNeighbors(v));
-        R2.insert(v);
-        for(const auto &u: nbd){
-          if(X.count(u) > 0 && u != v){X2.insert(u);}
-          if(P.count(u) > 0 && u != v){P2.insert(u);}
+        auto it = P.begin();
+        while (it != P.end()) {
+          const auto v = *it;
+          T_NodeSet<T> X2, R2(R), P2, nbd(inOutNeighbors(v));
+          R2.insert(v);
+          for (const auto &u : nbd) {
+            if (X.count(u) > 0 && u != v) {
+              X2.insert(u);
+            }
+            if (P.count(u) > 0 && u != v) {
+              P2.insert(u);
+            }
+          }
+          rec(R2, P2, X2);
+          X.insert(v);
+          it = P.erase(it);
         }
-        rec(R2,P2,X2);
-        X.insert(v);
-        it = P.erase(it);
-      }
-    };
-
-  rec(_R,_P,_X);
+      };
+
+  rec(_R, _P, _X);
   result.success = true;
   result.maximalCliques = maximalCliques;
   return result;
 }
-  
+
 }  // namespace CXXGraph
-#endif  
+#endif
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 = cachedAdjMatrix->size();
 
   // setting all the distances initially to INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;
@@ -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 = cachedAdjMatrix->size();
 
   // setting all the distances initially to INF_DOUBLE
   std::unordered_map<shared<const Node<T>>, double, nodeHash<T>> dist;

diff --git a/include/CXXGraph/Graph/Graph.h b/include/CXXGraph/Graph/Graph.h
@@ -27,6 +27,7 @@
 #include "CXXGraph/Graph/Algorithm/BestFirstSearch_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/Boruvka_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/BreadthFirstSearch_impl.hpp"
+#include "CXXGraph/Graph/Algorithm/BronKerbosch_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/Connectivity_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/CycleDetection_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/DepthFirstSearch_impl.hpp"
@@ -42,7 +43,6 @@
 #include "CXXGraph/Graph/Algorithm/TopologicalSort_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/TransitiveReduction_impl.hpp"
 #include "CXXGraph/Graph/Algorithm/welshPowellColoring_impl.hpp"
-#include "CXXGraph/Graph/Algorithm/BronKerbosch_impl.hpp"
 
 // IO Operation
 #include "CXXGraph/Graph/IO/IOUtility_impl.hpp"

diff --git a/include/CXXGraph/Graph/Graph_decl.h b/include/CXXGraph/Graph/Graph_decl.h
@@ -663,7 +663,7 @@ class Graph {
    * mst: vector containing id of nodes in minimum spanning tree & cost of MST
    * mstCost: Cost of MST
    * errorMessage: "" if no error ELSE report the encountered error
-   */	
+   */
   virtual const MstResult boruvka_deterministic() const;
 
   /**
@@ -704,7 +704,6 @@ class Graph {
    *
    */
 
-
   virtual const BronKerboschResult<T> bron_kerbosch() const;
 
   virtual const std::vector<Node<T>> breadth_first_search(

diff --git a/include/CXXGraph/Graph/Graph_impl.hpp b/include/CXXGraph/Graph/Graph_impl.hpp
@@ -22,8 +22,8 @@
 
 #pragma once
 
-#include <deque>
 #include <algorithm>
+#include <deque>
 
 #include "CXXGraph/Graph/Graph_decl.h"
 #include "CXXGraph/Utility/ConstString.hpp"

diff --git a/include/CXXGraph/Utility/Typedef.hpp b/include/CXXGraph/Utility/Typedef.hpp
@@ -237,13 +237,15 @@ struct BestFirstSearchResult_struct {
 template <typename T>
 using BestFirstSearchResult = BestFirstSearchResult_struct<T>;
 
+// Struct that contains information about BronKerbosch algorithm results
 template <typename T>
 struct BronKerboschResult_struct {
   bool success = false;
   std::string errorMessage = "";
-  std::vector<std::unordered_set<shared<const Node<T>>, nodeHash<T>>> maximalCliques = {};
+  std::vector<std::unordered_set<shared<const Node<T>>, nodeHash<T>>>
+      maximalCliques = {};
 };
-template<typename T>
+template <typename T>
 using BronKerboschResult = BronKerboschResult_struct<T>;
 
 ///////////////////////////////////////////////////////////////////////////////////

diff --git a/test/BronKerboschTest.cpp b/test/BronKerboschTest.cpp
@@ -12,20 +12,19 @@ using shared = std::shared_ptr<T>;
 using std::make_shared;
 using std::make_unique;
 
-
 TEST(BronKerboschTest, test_1) {
   CXXGraph::Node<int> node0("0", 0);
   CXXGraph::Node<int> node1("1", 1);
   CXXGraph::Node<int> node2("2", 2);
   CXXGraph::Node<int> node3("3", 3);
   CXXGraph::Node<int> node4("4", 4);
 
-  CXXGraph::UndirectedEdge<int> edge0(0,node0,node1);
-  CXXGraph::UndirectedEdge<int> edge1(0,node0,node2);
-  CXXGraph::UndirectedEdge<int> edge2(0,node2,node1);
-  CXXGraph::UndirectedEdge<int> edge3(0,node2,node3);
-  CXXGraph::UndirectedEdge<int> edge4(0,node2,node4);
-  CXXGraph::UndirectedEdge<int> edge5(0,node3,node4);
+  CXXGraph::UndirectedEdge<int> edge0(0, node0, node1);
+  CXXGraph::UndirectedEdge<int> edge1(0, node0, node2);
+  CXXGraph::UndirectedEdge<int> edge2(0, node2, node1);
+  CXXGraph::UndirectedEdge<int> edge3(0, node2, node3);
+  CXXGraph::UndirectedEdge<int> edge4(0, node2, node4);
+  CXXGraph::UndirectedEdge<int> edge5(0, node3, node4);
 
   CXXGraph::T_EdgeSet<int> edgeSet;
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge0));
@@ -34,24 +33,34 @@ TEST(BronKerboschTest, test_1) {
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge3));
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge4));
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge5));
-  
+
   CXXGraph::Graph<int> graph(edgeSet);
   CXXGraph::BronKerboschResult<int> res = graph.bron_kerbosch();
 
   ASSERT_TRUE(res.success);
-  ASSERT_EQ(res.maximalCliques.size(),2);
+  ASSERT_EQ(res.maximalCliques.size(), 2);
   ASSERT_EQ(res.errorMessage, "");
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node0),make_shared<CXXGraph::Node<int>>(node1),make_shared<CXXGraph::Node<int>>(node2) })!= res.maximalCliques.end());
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node2),make_shared<CXXGraph::Node<int>>(node3),make_shared<CXXGraph::Node<int>>(node4) }) != res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node0),
+                            make_shared<CXXGraph::Node<int>>(node1),
+                            make_shared<CXXGraph::Node<int>>(node2)}) !=
+              res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node2),
+                            make_shared<CXXGraph::Node<int>>(node3),
+                            make_shared<CXXGraph::Node<int>>(node4)}) !=
+              res.maximalCliques.end());
 }
 
-//Empty graph E_5
-TEST(BronKerboschTest,test_2){
-  CXXGraph::Node<int> node0("0",0);
-  CXXGraph::Node<int> node1("1",1);
-  CXXGraph::Node<int> node2("2",2);
-  CXXGraph::Node<int> node3("3",3);
-  CXXGraph::Node<int> node4("4",4);
+// Empty graph E_5
+TEST(BronKerboschTest, test_2) {
+  CXXGraph::Node<int> node0("0", 0);
+  CXXGraph::Node<int> node1("1", 1);
+  CXXGraph::Node<int> node2("2", 2);
+  CXXGraph::Node<int> node3("3", 3);
+  CXXGraph::Node<int> node4("4", 4);
 
   CXXGraph::T_EdgeSet<int> edgeSet;
   CXXGraph::Graph<int> graph(edgeSet);
@@ -64,34 +73,48 @@ TEST(BronKerboschTest,test_2){
 
   CXXGraph::BronKerboschResult<int> res = graph.bron_kerbosch();
   ASSERT_TRUE(res.success);
-  ASSERT_EQ(res.maximalCliques.size(),5);
+  ASSERT_EQ(res.maximalCliques.size(), 5);
   ASSERT_EQ(res.errorMessage, "");
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node0) }) != res.maximalCliques.end());
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node1) }) != res.maximalCliques.end());
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node2) }) != res.maximalCliques.end());
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node3) }) != res.maximalCliques.end());
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node4) }) != res.maximalCliques.end());
-
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node0)}) !=
+              res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node1)}) !=
+              res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node2)}) !=
+              res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node3)}) !=
+              res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node4)}) !=
+              res.maximalCliques.end());
 }
 
-//Complete graph K_5
-TEST(BronKerboschTest,test_3){
-  CXXGraph::Node<int> node0("0",0);
-  CXXGraph::Node<int> node1("1",1);
-  CXXGraph::Node<int> node2("2",2);
-  CXXGraph::Node<int> node3("3",3);
-  CXXGraph::Node<int> node4("4",4);
-
-  CXXGraph::UndirectedEdge<int> edge0(0,node0,node1);
-  CXXGraph::UndirectedEdge<int> edge1(1,node0,node2);
-  CXXGraph::UndirectedEdge<int> edge2(2,node0,node3);
-  CXXGraph::UndirectedEdge<int> edge3(3,node0,node4);
-  CXXGraph::UndirectedEdge<int> edge4(4,node1,node2);
-  CXXGraph::UndirectedEdge<int> edge5(5,node1,node3);
-  CXXGraph::UndirectedEdge<int> edge6(6,node1,node4);
-  CXXGraph::UndirectedEdge<int> edge7(7,node2,node3);
-  CXXGraph::UndirectedEdge<int> edge8(8,node2,node4);
-  CXXGraph::UndirectedEdge<int> edge9(9,node3,node4);
+// Complete graph K_5
+TEST(BronKerboschTest, test_3) {
+  CXXGraph::Node<int> node0("0", 0);
+  CXXGraph::Node<int> node1("1", 1);
+  CXXGraph::Node<int> node2("2", 2);
+  CXXGraph::Node<int> node3("3", 3);
+  CXXGraph::Node<int> node4("4", 4);
+
+  CXXGraph::UndirectedEdge<int> edge0(0, node0, node1);
+  CXXGraph::UndirectedEdge<int> edge1(1, node0, node2);
+  CXXGraph::UndirectedEdge<int> edge2(2, node0, node3);
+  CXXGraph::UndirectedEdge<int> edge3(3, node0, node4);
+  CXXGraph::UndirectedEdge<int> edge4(4, node1, node2);
+  CXXGraph::UndirectedEdge<int> edge5(5, node1, node3);
+  CXXGraph::UndirectedEdge<int> edge6(6, node1, node4);
+  CXXGraph::UndirectedEdge<int> edge7(7, node2, node3);
+  CXXGraph::UndirectedEdge<int> edge8(8, node2, node4);
+  CXXGraph::UndirectedEdge<int> edge9(9, node3, node4);
 
   CXXGraph::T_EdgeSet<int> edgeSet;
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge0));
@@ -109,26 +132,32 @@ TEST(BronKerboschTest,test_3){
   CXXGraph::BronKerboschResult<int> res = graph.bron_kerbosch();
 
   ASSERT_TRUE(res.success);
-  ASSERT_EQ(res.maximalCliques.size(),1);
+  ASSERT_EQ(res.maximalCliques.size(), 1);
   ASSERT_EQ(res.errorMessage, "");
-  ASSERT_TRUE(std::find(res.maximalCliques.begin(),res.maximalCliques.end(),CXXGraph::T_NodeSet<int>{ make_shared<CXXGraph::Node<int>>(node0),make_shared<CXXGraph::Node<int>>(node1),make_shared<CXXGraph::Node<int>>(node2),make_shared<CXXGraph::Node<int>>(node3),make_shared<CXXGraph::Node<int>>(node4) }) != res.maximalCliques.end());
+  ASSERT_TRUE(std::find(res.maximalCliques.begin(), res.maximalCliques.end(),
+                        CXXGraph::T_NodeSet<int>{
+                            make_shared<CXXGraph::Node<int>>(node0),
+                            make_shared<CXXGraph::Node<int>>(node1),
+                            make_shared<CXXGraph::Node<int>>(node2),
+                            make_shared<CXXGraph::Node<int>>(node3),
+                            make_shared<CXXGraph::Node<int>>(node4)}) !=
+              res.maximalCliques.end());
 }
 
-
-//Graph with a directed edge
-TEST(BronKerboschTest,test_4){
+// Graph with a directed edge
+TEST(BronKerboschTest, test_4) {
   CXXGraph::Node<int> node0("0", 0);
   CXXGraph::Node<int> node1("1", 1);
   CXXGraph::Node<int> node2("2", 2);
   CXXGraph::Node<int> node3("3", 3);
   CXXGraph::Node<int> node4("4", 4);
 
-  CXXGraph::DirectedEdge<int> edge0(0,node0,node1);
-  CXXGraph::UndirectedEdge<int> edge1(0,node0,node2);
-  CXXGraph::UndirectedEdge<int> edge2(0,node2,node1);
-  CXXGraph::UndirectedEdge<int> edge3(0,node2,node3);
-  CXXGraph::UndirectedEdge<int> edge4(0,node2,node4);
-  CXXGraph::UndirectedEdge<int> edge5(0,node3,node4);
+  CXXGraph::DirectedEdge<int> edge0(0, node0, node1);
+  CXXGraph::UndirectedEdge<int> edge1(0, node0, node2);
+  CXXGraph::UndirectedEdge<int> edge2(0, node2, node1);
+  CXXGraph::UndirectedEdge<int> edge3(0, node2, node3);
+  CXXGraph::UndirectedEdge<int> edge4(0, node2, node4);
+  CXXGraph::UndirectedEdge<int> edge5(0, node3, node4);
 
   CXXGraph::T_EdgeSet<int> edgeSet;
   edgeSet.insert(make_shared<CXXGraph::DirectedEdge<int>>(edge0));
@@ -137,11 +166,10 @@ TEST(BronKerboschTest,test_4){
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge3));
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge4));
   edgeSet.insert(make_shared<CXXGraph::UndirectedEdge<int>>(edge5));
-  
+
   CXXGraph::Graph<int> graph(edgeSet);
   CXXGraph::BronKerboschResult<int> res = graph.bron_kerbosch();
 
   ASSERT_FALSE(res.success);
-  ASSERT_EQ(res.errorMessage,"Graph is directed");
+  ASSERT_EQ(res.errorMessage, "Graph is directed");
 }
-