Merge pull request #168 from Musicaldg/feat/community-cpp-binding

Feat/community cpp binding

Author: eggpig

.gitignore

@@ -206,4 +206,7 @@ Temporary Items
 .apdisk
 tmp_test/allset_test.py
 tmp_test/
-RandomNetwork.txt
+RandomNetwork.txt
+TEST/
+CON_TEST/
+Comm_TEST/

cpp_easygraph/classes/linkgraph.h

@@ -86,4 +86,6 @@ struct compare_node {
 	bool operator < (const compare_node &rhs) const {
 		return d > rhs.d;
 	}
-};
+};
+
+std::vector<double> _dijkstra(const Graph_L& G_l, int source, int target);

cpp_easygraph/cpp_easygraph.cpp

@@ -105,4 +105,16 @@ PYBIND11_MODULE(cpp_easygraph, m) {
     m.def("cpp_eccentricity", &eccentricity, py::arg("G"), py::arg("v") = py::none(), py::arg("sp") = py::none());
     m.def("cpp_connected_components_undirected", &connected_component_undirected, py::arg("G"));
     m.def("cpp_connected_components_directed", &connected_component_directed, py::arg("G"));
+
+    // community methods
+    m.def("cpp_modularity", &cpp_modularity, py::arg("G"), py::arg("communities"), py::arg("weight") = py::str("weight"));
+    m.def("cpp_greedy_modularity_communities", &cpp_greedy_modularity_communities, py::arg("G"), py::arg("weight") = py::str("weight"));
+    m.def("cpp_enumerate_subgraph", &cpp_enumerate_subgraph, py::arg("G"), py::arg("k"));
+    m.def("cpp_random_enumerate_subgraph", &cpp_random_enumerate_subgraph, py::arg("G"), py::arg("k"), py::arg("cut_prob"));
+    m.def("cpp_louvain_communities", &cpp_louvain_communities, py::arg("G"), py::arg("weight") = py::str("weight"), py::arg("threshold") = py::float_(0.00002), py::arg("resolution") = py::float_(1.0));
+    m.def("cpp_louvain_communities_serial", &cpp_louvain_communities_serial, py::arg("G"), py::arg("weight") = py::str("weight"), py::arg("threshold") = py::float_(0.00002), py::arg("resolution") = py::float_(1.0));
+    m.def("cpp_LPA", &cpp_LPA, py::arg("G"));
+    m.def("cpp_ego_graph", &cpp_ego_graph, py::arg("G"), py::arg("n"), py::arg("radius") = py::int_(1), py::arg("center") = py::bool_(true), py::arg("undirected") = py::bool_(false), py::arg("distance") = py::none());
+    m.def("cpp_ego_graph_csr", &cpp_ego_graph_csr, py::arg("G"), py::arg("n"), py::arg("radius") = py::int_(1), py::arg("center") = py::bool_(true), py::arg("undirected") = py::bool_(false), py::arg("distance") = py::none());
+    m.def("cpp_localsearch", &cpp_localsearch, py::arg("G"), py::arg("center_num") = py::none(), py::arg("auto_choose_centers") = py::bool_(false), py::arg("maximum_tree") = py::bool_(true), py::arg("seed") = py::none(), py::arg("self_loop") = py::bool_(false));
 }

cpp_easygraph/functions/__init__.h

@@ -6,4 +6,5 @@
 #include "structural_holes/__init__.h"
 #include "cores/__init__.h"
 #include "centrality/__init__.h"
-#include "pagerank/__init__.h"
+#include "pagerank/__init__.h"
+#include "community/__init__.h"

cpp_easygraph/functions/community/LPA.cpp

@@ -0,0 +1,146 @@
+#include <vector>
+#include <unordered_map>
+#include <algorithm>
+#include <random>
+#include <queue>
+#include <cstdint>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "../../classes/graph.h"
+#include "../../classes/linkgraph.h"
+#include "../../common/utils.h"
+
+namespace py = pybind11;
+using namespace std;
+
+py::object cpp_LPA(py::object G) {
+    Graph& G_ = G.cast<Graph&>();
+    Graph_L linkgraph = G_._get_linkgraph_structure();
+    int n = linkgraph.n;
+    
+    py::dict id_to_node = G_.id_to_node;
+    
+    if (n <= 1) {
+        py::dict result;
+        if (n == 1) {
+            py::list node_list;
+            node_list.append(id_to_node[py::cast(1)]);
+            result[py::cast(1)] = node_list;
+        }
+        return result;
+    }
+    
+    vector<vector<int>> adj(n + 1);
+    for (int u = 1; u <= n; ++u) {
+        for (int e = linkgraph.head[u]; e != -1; e = linkgraph.edges[e].next) {
+            int v = linkgraph.edges[e].to;
+            if (u != v) {
+                adj[u].push_back(v);
+            }
+        }
+    }
+    
+    for (int u = 1; u <= n; ++u) {
+        if (adj[u].size() > 1) {
+            sort(adj[u].begin(), adj[u].end());
+            adj[u].erase(unique(adj[u].begin(), adj[u].end()), adj[u].end());
+        }
+    }
+
+    vector<int> labels(n);
+    vector<int> nodes(n);
+    for (int i = 0; i < n; ++i) {
+        labels[i] = i;
+        nodes[i] = i + 1;
+    }
+    
+    random_device rd;
+    mt19937 gen(rd());
+    
+    const int MAX_ITERATIONS = 1000;
+    int iteration_count = 0;
+    
+    vector<int> label_count(n, 0);
+    vector<int> active_labels;
+    active_labels.reserve(128);
+    
+    while (iteration_count < MAX_ITERATIONS) {
+        iteration_count++;
+        
+        shuffle(nodes.begin(), nodes.end(), gen);
+        
+        bool changed = false;
+        for (int node : nodes) {
+            int max_count = 0;
+            
+            for (int neighbor : adj[node]) {
+                int neighbor_label = labels[neighbor - 1];
+                if (label_count[neighbor_label] == 0) {
+                    active_labels.push_back(neighbor_label);
+                }
+                label_count[neighbor_label]++;
+                if (label_count[neighbor_label] > max_count) {
+                    max_count = label_count[neighbor_label];
+                }
+            }
+            
+            if (max_count > 0) {
+                int current_label = labels[node - 1];
+                
+                vector<int> best_labels;
+                for (int label : active_labels) {
+                    if (label_count[label] == max_count) {
+                        best_labels.push_back(label);
+                    }
+                }
+                
+                bool current_is_best = false;
+                for (int label : best_labels) {
+                    if (label == current_label) {
+                        current_is_best = true;
+                        break;
+                    }
+                }
+                
+                if (!current_is_best) {
+                    changed = true;
+                    
+                    if (best_labels.size() == 1) {
+                        labels[node - 1] = best_labels[0];
+                    } else {
+                        uniform_int_distribution<> dis(0, best_labels.size() - 1);
+                        labels[node - 1] = best_labels[dis(gen)];
+                    }
+                }
+            }
+            
+            for (int label : active_labels) {
+                label_count[label] = 0;
+            }
+            active_labels.clear();
+        }
+        
+        if (!changed) {
+            break;
+        }
+    }
+    
+    unordered_map<int, vector<int>> label_to_nodes;
+    for (int i = 0; i < n; ++i) {
+        int label = labels[i];
+        label_to_nodes[label].push_back(i + 1);  
+    }
+    
+    py::dict result;
+    int community_id = 1;
+    for (const auto& pair : label_to_nodes) {
+        py::list node_list;
+        for (int internal_id : pair.second) {
+            node_list.append(id_to_node[py::cast(internal_id)]);
+        }
+        result[py::cast(community_id)] = node_list;
+        community_id++;
+    }
+    
+    return result;
+}

cpp_easygraph/functions/community/LPA.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+py::object cpp_LPA(py::object G);

cpp_easygraph/functions/community/__init__.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "modularity.h"
+#include "greedy_modularity.h"
+#include "motif.h"
+#include "louvain.h"
+#include "LPA.h"
+#include "ego_graph.h"
+#include "graph_coloring.h"
+#include "localsearch.h"

cpp_easygraph/functions/community/ego_graph.cpp

@@ -0,0 +1,155 @@
+#include "ego_graph.h"
+#include "subgraph.h"
+#include "../../classes/graph.h"
+#include "../../classes/directed_graph.h"
+#include "../../classes/csr_graph.h"
+#include "../../common/utils.h"
+#include "../../classes/linkgraph.h"
+#include "../path/path.h"
+#include <algorithm>
+
+
+struct _EgoGraphCore {
+    Graph_L G_l;                                  
+    std::vector<node_t> node_ids;                 
+    std::unordered_map<node_t, int> node_to_idx;  
+    py::dict id_to_node_py;                       
+    bool has_error = false;                       
+};
+
+
+static _EgoGraphCore _cpp_ego_graph_compute_impl(
+    Graph& G_,
+    py::object n,
+    double radius_val,
+    bool center_val,
+    bool undirected_val,
+    bool is_directed,
+    const std::string& weight_key) {
+
+    _EgoGraphCore out;
+
+    if (G_.node_to_id.contains(n) == 0) {
+        PyErr_Format(PyExc_KeyError, "Node %R is not in the graph.", n.ptr());
+        out.has_error = true;
+        return out;
+    }
+
+    node_t center_id = G_.node_to_id[n].cast<node_t>();
+    out.id_to_node_py = G_.id_to_node;
+
+    if (G_.linkgraph_dirty || G_.linkgraph_structure.max_deg == -1) {
+        if (undirected_val) {
+            out.G_l = graph_to_linkgraph(G_, false, weight_key, true, false);
+        } else {
+            out.G_l = graph_to_linkgraph(G_, is_directed, weight_key, true, false);
+        }
+        G_.linkgraph_dirty = false;
+        G_.linkgraph_structure = out.G_l;  // also cache the freshly built linkgraph
+    } else {
+        out.G_l = G_.linkgraph_structure;
+    }
+
+    std::vector<double> dist = _dijkstra(out.G_l, center_id, -1);
+    int N = out.G_l.n;
+    for (int i = 1; i <= N; i++) {
+        if (dist[i] > radius_val) continue;
+        if (!center_val && i == (int)center_id) continue;
+        out.node_to_idx[i] = (int)out.node_ids.size();
+        out.node_ids.push_back(i);
+    }
+    return out;
+}
+
+
+static _EgoGraphCore _cpp_ego_graph_compute(
+    py::object G,
+    py::object n,
+    py::object radius,
+    py::object center,
+    py::object undirected,
+    py::object distance) {
+
+    bool is_directed     = G.attr("is_directed")().cast<bool>();
+    bool center_val      = center.cast<bool>();
+    bool undirected_val  = undirected.cast<bool>();
+    double radius_val    = radius.cast<double>();
+    std::string weight_key = weight_to_string(distance);
+
+    if (is_directed) {
+        DiGraph& G_ = G.cast<DiGraph&>();
+        return _cpp_ego_graph_compute_impl(
+            G_, n, radius_val, center_val, undirected_val, is_directed, weight_key);
+    } else {
+        Graph& G_ = G.cast<Graph&>();
+        return _cpp_ego_graph_compute_impl(
+            G_, n, radius_val, center_val, undirected_val, is_directed, weight_key);
+    }
+}
+
+
+py::object cpp_ego_graph(
+    py::object G,
+    py::object n,
+    py::object radius,
+    py::object center,
+    py::object undirected,
+    py::object distance) {
+
+    _EgoGraphCore core = _cpp_ego_graph_compute(G, n, radius, center, undirected, distance);
+    if (core.has_error) return py::none();
+
+    return nodes_subgraph_cpp(G, core.node_ids);
+}
+
+
+py::object cpp_ego_graph_csr(
+    py::object G,
+    py::object n,
+    py::object radius,
+    py::object center,
+    py::object undirected,
+    py::object distance) {
+
+    _EgoGraphCore core = _cpp_ego_graph_compute(G, n, radius, center, undirected, distance);
+    if (core.has_error) return py::none();
+
+    int n_nodes = (int)core.node_ids.size();
+    if (n_nodes == 0) {
+        return py::dict();
+    }
+
+    std::vector<int> V(n_nodes + 1, 0);
+    std::vector<int> E;
+    std::vector<double> W;
+
+    for (int new_u = 0; new_u < n_nodes; new_u++) {
+        node_t u = core.node_ids[new_u];
+        V[new_u + 1] = V[new_u];
+
+        int edge_idx = core.G_l.head[u];
+        while (edge_idx != -1 && edge_idx < core.G_l.e) {
+            node_t v = core.G_l.edges[edge_idx].to;
+            auto it = core.node_to_idx.find(v);
+            if (it != core.node_to_idx.end()) {
+                E.push_back(it->second);
+                W.push_back(core.G_l.edges[edge_idx].w);
+                V[new_u + 1]++;
+            }
+            edge_idx = core.G_l.edges[edge_idx].next;
+        }
+    }
+
+    py::list original_nodes;
+    for (node_t internal_id : core.node_ids) {
+        original_nodes.append(core.id_to_node_py[py::cast(internal_id)]);
+    }
+
+    py::dict result;
+    result["nodes"] = original_nodes;
+    result["V"] = py::cast(V);
+    result["E"] = py::cast(E);
+    result["W"] = py::cast(W);
+
+    return result;
+}

cpp_easygraph/functions/community/ego_graph.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+py::object cpp_ego_graph(
+    py::object G,
+    py::object n,
+    py::object radius = py::int_(1),
+    py::object center = py::bool_(true),
+    py::object undirected = py::bool_(false),
+    py::object distance = py::none()
+);
+
+py::object cpp_ego_graph_csr(
+    py::object G,
+    py::object n,
+    py::object radius = py::int_(1),
+    py::object center = py::bool_(true),
+    py::object undirected = py::bool_(false),
+    py::object distance = py::none()
+);