Python-EasyGraph 1.6.1__tar.gz → 1.6.2__tar.gz

{python_easygraph-1.6.1/Python_EasyGraph.egg-info → python_easygraph-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Python-EasyGraph
-Version: 1.6.1
+Version: 1.6.2
 Summary: Easy Graph
 Home-page: https://github.com/easy-graph/Easy-Graph
 Author: Fudan DataNET Group
@@ -71,7 +71,7 @@ ___________________________________________________________________________
 [python-url]: https://pypi.org/project/Python-EasyGraph/
 [license-image]: https://img.shields.io/pypi/l/Python-EasyGraph?label=License
 [license-url]: https://github.com/easy-graph/Easy-Graph/blob/master/LICENSE
-[downloads-image]: https://static.pepy.tech/personalized-badge/python-easygraph?period=total&units=international_system&left_color=brightgreen&right_color=yellowgreen&left_text=Downloads
+[downloads-image]: https://img.shields.io/pepy/dt/python-easygraph?label=Downloads&labelColor=brightgreen&color=yellowgreen
 [downloads-url]: https://pypi.org/project/Python-EasyGraph/
 
 - **Documentation:** https://easy-graph.github.io/
@@ -118,6 +118,7 @@ It bridges the gap between EasyGraph and higher-order relationships. EasyHypergr
 - [11-04-2023] [EasyGraph：多功能、跨平台、高效率的跨学科网络分析库 (in Chinese)](https://swarma.org/?p=46252)
 
 ## 🚀 Releases & Milestones
+- [05-07-2026] EasyGraph **v1.6.1** released (Add OpenMP-powered path-based functions)
 - [02-01-2026] EasyGraph **v1.6** released (OpenMP-powered functions for large network analysis)
 - **[01-16-2026] 🎉 1M Downloads! Thanks to our amazing community!**
 - [01-01-2026] EasyGraph **v1.5.3** released ([The Hypergraph Interchange Format (HIF) standard](https://github.com/HIF-org/HIF-standard))

{python_easygraph-1.6.1 → python_easygraph-1.6.2/Python_EasyGraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Python-EasyGraph
-Version: 1.6.1
+Version: 1.6.2
 Summary: Easy Graph
 Home-page: https://github.com/easy-graph/Easy-Graph
 Author: Fudan DataNET Group
@@ -71,7 +71,7 @@ ___________________________________________________________________________
 [python-url]: https://pypi.org/project/Python-EasyGraph/
 [license-image]: https://img.shields.io/pypi/l/Python-EasyGraph?label=License
 [license-url]: https://github.com/easy-graph/Easy-Graph/blob/master/LICENSE
-[downloads-image]: https://static.pepy.tech/personalized-badge/python-easygraph?period=total&units=international_system&left_color=brightgreen&right_color=yellowgreen&left_text=Downloads
+[downloads-image]: https://img.shields.io/pepy/dt/python-easygraph?label=Downloads&labelColor=brightgreen&color=yellowgreen
 [downloads-url]: https://pypi.org/project/Python-EasyGraph/
 
 - **Documentation:** https://easy-graph.github.io/
@@ -118,6 +118,7 @@ It bridges the gap between EasyGraph and higher-order relationships. EasyHypergr
 - [11-04-2023] [EasyGraph：多功能、跨平台、高效率的跨学科网络分析库 (in Chinese)](https://swarma.org/?p=46252)
 
 ## 🚀 Releases & Milestones
+- [05-07-2026] EasyGraph **v1.6.1** released (Add OpenMP-powered path-based functions)
 - [02-01-2026] EasyGraph **v1.6** released (OpenMP-powered functions for large network analysis)
 - **[01-16-2026] 🎉 1M Downloads! Thanks to our amazing community!**
 - [01-01-2026] EasyGraph **v1.5.3** released ([The Hypergraph Interchange Format (HIF) standard](https://github.com/HIF-org/HIF-standard))

{python_easygraph-1.6.1 → python_easygraph-1.6.2}/Python_EasyGraph.egg-info/SOURCES.txt

@@ -40,6 +40,35 @@ cpp_easygraph/functions/centrality/closeness.cpp
 cpp_easygraph/functions/centrality/degree.cpp
 cpp_easygraph/functions/centrality/eigenvector.cpp
 cpp_easygraph/functions/centrality/katz_centrality.cpp
+cpp_easygraph/functions/community/LPA.cpp
+cpp_easygraph/functions/community/LPA.h
+cpp_easygraph/functions/community/__init__.h
+cpp_easygraph/functions/community/ego_graph.cpp
+cpp_easygraph/functions/community/ego_graph.h
+cpp_easygraph/functions/community/graph_coloring.cpp
+cpp_easygraph/functions/community/graph_coloring.h
+cpp_easygraph/functions/community/greedy_modularity.cpp
+cpp_easygraph/functions/community/greedy_modularity.h
+cpp_easygraph/functions/community/indexed_heap.h
+cpp_easygraph/functions/community/localsearch.cpp
+cpp_easygraph/functions/community/localsearch.h
+cpp_easygraph/functions/community/louvain.cpp
+cpp_easygraph/functions/community/louvain.h
+cpp_easygraph/functions/community/modularity.cpp
+cpp_easygraph/functions/community/modularity.h
+cpp_easygraph/functions/community/motif.cpp
+cpp_easygraph/functions/community/motif.h
+cpp_easygraph/functions/community/subgraph.cpp
+cpp_easygraph/functions/community/subgraph.h
+cpp_easygraph/functions/community/tests/__init__.py
+cpp_easygraph/functions/community/tests/cpp_LPA_test.py
+cpp_easygraph/functions/community/tests/cpp_ego_graph_test.py
+cpp_easygraph/functions/community/tests/cpp_enumerate_subgraph_test.py
+cpp_easygraph/functions/community/tests/cpp_greedy_modularity_test.py
+cpp_easygraph/functions/community/tests/cpp_localsearch_test.py
+cpp_easygraph/functions/community/tests/cpp_louvain_test.py
+cpp_easygraph/functions/community/tests/cpp_modularity_test.py
+cpp_easygraph/functions/community/tests/run_all_tests.py
 cpp_easygraph/functions/components/__init__.h
 cpp_easygraph/functions/components/biconnected.cpp
 cpp_easygraph/functions/components/biconnected.h

{python_easygraph-1.6.1 → python_easygraph-1.6.2}/README.md

@@ -16,7 +16,7 @@ ___________________________________________________________________________
 [python-url]: https://pypi.org/project/Python-EasyGraph/
 [license-image]: https://img.shields.io/pypi/l/Python-EasyGraph?label=License
 [license-url]: https://github.com/easy-graph/Easy-Graph/blob/master/LICENSE
-[downloads-image]: https://static.pepy.tech/personalized-badge/python-easygraph?period=total&units=international_system&left_color=brightgreen&right_color=yellowgreen&left_text=Downloads
+[downloads-image]: https://img.shields.io/pepy/dt/python-easygraph?label=Downloads&labelColor=brightgreen&color=yellowgreen
 [downloads-url]: https://pypi.org/project/Python-EasyGraph/
 
 - **Documentation:** https://easy-graph.github.io/
@@ -63,6 +63,7 @@ It bridges the gap between EasyGraph and higher-order relationships. EasyHypergr
 - [11-04-2023] [EasyGraph：多功能、跨平台、高效率的跨学科网络分析库 (in Chinese)](https://swarma.org/?p=46252)
 
 ## 🚀 Releases & Milestones
+- [05-07-2026] EasyGraph **v1.6.1** released (Add OpenMP-powered path-based functions)
 - [02-01-2026] EasyGraph **v1.6** released (OpenMP-powered functions for large network analysis)
 - **[01-16-2026] 🎉 1M Downloads! Thanks to our amazing community!**
 - [01-01-2026] EasyGraph **v1.5.3** released ([The Hypergraph Interchange Format (HIF) standard](https://github.com/HIF-org/HIF-standard))

{python_easygraph-1.6.1 → python_easygraph-1.6.2}/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);

{python_easygraph-1.6.1 → python_easygraph-1.6.2}/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));
 }

{python_easygraph-1.6.1 → python_easygraph-1.6.2}/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"

python_easygraph-1.6.2/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;
+}

python_easygraph-1.6.2/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);

python_easygraph-1.6.2/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"

python_easygraph-1.6.2/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;
+}

python_easygraph-1.6.2/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()
+);

python_easygraph-1.6.2/cpp_easygraph/functions/community/graph_coloring.cpp

@@ -0,0 +1,135 @@
+#include <vector>
+#include <unordered_map>
+#include <algorithm>
+#include <iostream>
+#include <random>
+#include <numeric>
+#include <cstdint>
+#include <chrono>
+#include <queue>
+#include <cstring>
+
+#ifdef _OPENMP
+#include <omp.h>
+#else
+#warning "OpenMP is not available: omp_graph_coloring will fall back to single-threaded execution."
+#endif
+
+#include "../../classes/linkgraph.h"
+
+using namespace std;
+
+vector<int> greedy_graph_coloring(const Graph_L& G) {
+    int n = G.n;
+    if (n == 0) return vector<int>();
+
+    vector<int> degree(n + 1, 0);
+    for (int v = 1; v <= n; ++v) {
+        for (int e = G.head[v]; e != -1; e = G.edges[e].next) {
+            degree[v]++;
+        }
+    }
+
+    vector<int> nodes(n);
+    iota(nodes.begin(), nodes.end(), 1);
+    sort(nodes.begin(), nodes.end(), [&degree](int a, int b) {
+        return degree[a] > degree[b];
+    });
+
+    vector<int> colors(n, -1);
+    vector<int> used(n + 1, -1);
+
+    for (int u : nodes) {
+        for (int e = G.head[u]; e != -1; e = G.edges[e].next) {
+            int v = G.edges[e].to;
+            if (v == u) continue;
+            int neighbor_color = colors[v - 1];
+            if (neighbor_color != -1) {
+                used[neighbor_color] = u;
+            }
+        }
+
+        int cr = 0;
+        while (cr <= n && used[cr] == u) {
+            cr++;
+        }
+        colors[u - 1] = cr;
+    }
+
+    return colors;
+}
+
+vector<int> omp_graph_coloring(const Graph_L& G) {
+    int n = G.n;
+    if (n == 0) return vector<int>();
+
+    vector<int> degree(n + 1, 0);
+    for (int v = 1; v <= n; ++v) {
+        for (int e = G.head[v]; e != -1; e = G.edges[e].next) {
+            degree[v]++;
+        }
+    }
+
+    vector<int> nodes(n);
+    iota(nodes.begin(), nodes.end(), 1);
+    sort(nodes.begin(), nodes.end(), [&degree](int a, int b) {
+        return degree[a] > degree[b];
+    });
+
+    vector<int> colors(n, -1);
+
+    #pragma omp parallel
+    {
+        vector<int> local_used(n + 1, -1);
+        
+        #pragma omp for schedule(guided)
+        for (int i = 0; i < n; ++i) {
+            int u = nodes[i];
+            
+            fill(local_used.begin(), local_used.end(), -1);
+            
+            for (int e = G.head[u]; e != -1; e = G.edges[e].next) {
+                int v = G.edges[e].to;
+                if (v == u) continue;
+                int neighbor_color = colors[v - 1];
+                if (neighbor_color != -1 && neighbor_color <= n) {
+                    local_used[neighbor_color] = u;
+                }
+            }
+            
+            int cr = 0;
+            while (cr <= n && local_used[cr] == u) {
+                cr++;
+            }
+            colors[u - 1] = cr;
+        }
+    }
+
+    return colors;
+}
+
+bool verify_coloring(const Graph_L& g, const vector<int>& colors) {
+    int n = g.n;
+    for (int v = 1; v <= n; v++) {
+        int v_color = colors[v - 1];
+        for (int e = g.head[v]; e != -1; e = g.edges[e].next) {
+            int u = g.edges[e].to;
+            if (u == v) continue;
+            int u_color = colors[u - 1];
+            if (v_color == u_color) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+int count_colors(const vector<int>& colors) {
+    int max_color = -1;
+    for (int c : colors) {
+        if (c > max_color) {
+            max_color = c;
+        }
+    }
+    return max_color + 1;
+}

python_easygraph-1.6.2/cpp_easygraph/functions/community/graph_coloring.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <vector>
+#include "../../classes/linkgraph.h"
+
+std::vector<int> greedy_graph_coloring(const Graph_L& G);
+
+std::vector<int> omp_graph_coloring(const Graph_L& G);
+
+bool verify_coloring(const Graph_L& g, const std::vector<int>& colors);
+
+int count_colors(const std::vector<int>& colors);