sgtlib 3.4.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

StructuralGT/__init__.py

@@ -24,7 +24,7 @@ of the GNU General Public License along with this program.  If not, see <https:/
 
 
 # Project Details
-__version__ = "3.4.0"
+__version__ = "3.4.1"
 __install_version__ = "3.3.9"
 __title__ = f"StructuralGT (v{__version__})"
 __author__ = "Dickson Owuor"

StructuralGT/compute/graph_analyzer.py

@@ -15,6 +15,7 @@ import multiprocessing
 import numpy as np
 import scipy as sp
 import pandas as pd
+import igraph as ig
 import networkx as nx
 import matplotlib.table as tbl
 import matplotlib.pyplot as plt
@@ -67,6 +68,15 @@ except cp.cuda.runtime.CUDARuntimeError:
 """
 
 
+def _worker_vertex_connectivity(ig_graph_obj, i, j):
+    try:
+        lnc = ig_graph_obj.vertex_connectivity(source=i, target=j, neighbors="negative")
+        return lnc if lnc != -1 else None
+    except Exception as err:
+        logging.exception("Computing iGraph ANC Error: %s", err, extra={'user': 'SGT Logs'})
+        return None
+
+
 class GraphAnalyzer(ProgressUpdate):
     """
     A class that computes all the user-selected graph theory metrics and writes the results in a PDF file.
@@ -247,22 +257,7 @@ class GraphAnalyzer(ProgressUpdate):
                 self.update_status([-1, "Task aborted."])
                 return None
             self.update_status([15, "Computing node connectivity..."])
-            if connected_graph:
-                # use_igraph = opt_gtc["compute_lang == 'C'"]["value"]
-                if self.use_igraph:
-                    # use iGraph Lib in C
-                    self.update_status([15, "Using iGraph library..."])
-                    avg_node_con = self.igraph_average_node_connectivity(graph)
-                else:
-                    # Use NetworkX Lib in Python
-                    self.update_status([15, "Using NetworkX library..."])
-                    if self.allow_mp:  # Multi-processing
-                        avg_node_con = self.average_node_connectivity(graph)
-                    else:
-                        avg_node_con = average_node_connectivity(graph)
-                avg_node_con = round(avg_node_con, 5)
-            else:
-                avg_node_con = np.nan
+            avg_node_con = self.compute_average_node_connectivity(graph, connected_graph)
             data_dict["parameter"].append("Average node connectivity")
             data_dict["value"].append(avg_node_con)
 
@@ -586,88 +581,147 @@ class GraphAnalyzer(ProgressUpdate):
 
         return ohms_dict, res
 
-    def average_node_connectivity(self, nx_graph: nx.Graph, flow_func=None):
+    def compute_average_node_connectivity(self, nx_graph: nx.Graph, is_graph_connected=False):
         r"""Returns the average connectivity of a graph G.
 
         The average connectivity `\bar{\kappa}` of a graph G is the average
         of local node connectivity over all pairs of the nx_graph nodes.
 
-        https://networkx.org/documentation/stable/_modules/networkx/algorithms/connectivity/connectivity.html#average_node_connectivity
-
-        Parameters
-        ----------
         :param nx_graph: NetworkX graph object.
-        :param flow_func : Function
-            A function for computing the maximum flow between a pair of nodes.
-            The function has to accept at least three parameters: a Digraph,
-            a source node, and a target node. And return a residual network
-            that follows NetworkX conventions (see: meth:`maximum_flow` for
-            details). If flow_func is None, the default maximum flow function
-            (:meth:`edmonds_karp`) is used. See :meth:`local_node_connectivity`
-            for details. The choice of the default function may change from
-            version to version and should not be relied on. Default value: None.
-
-        Returns
-        -------
-        K : float
-            Average node connectivity
-
-        References
-        ----------
-        [1]  Beineke, L., O. Oellermann, and r_network. Pippert (2002). The average
-                connectivity of a graph. Discrete mathematics 252(1-3), 31-45.
-                https://www.sciencedirect.com/science/article/pii/S0012365X01001807
-
+        :param is_graph_connected: Boolean
         """
 
-        if nx_graph.is_directed():
-            iter_func = itertools.permutations
-        else:
-            iter_func = itertools.combinations
-
-        # Reuse the auxiliary digraph and the residual network
-        a_digraph = nx.algorithms.connectivity.build_auxiliary_node_connectivity(nx_graph)
-        r_network = nx.algorithms.flow.build_residual_network(a_digraph, "capacity")
-        # kwargs = {"flow_func": flow_func, "auxiliary": a_digraph, "residual": r_network}
-
-        num, den = 0, 0
-        with multiprocessing.Pool() as pool:
-            items = [(nx_graph, u, v, flow_func, a_digraph, r_network) for u, v in iter_func(nx_graph, 2)]
-            for n in pool.starmap(nx.algorithms.connectivity.local_node_connectivity, items):
-                num += n
-                den += 1
-                if self.abort:
-                    self.update_status([-1, "Task aborted."])
-                    return 0
-        if den == 0:
-            return 0
-        return num / den
-
-    def igraph_average_node_connectivity(self, nx_graph: nx.Graph):
-        r"""Returns the average connectivity of a graph G.
+        def nx_average_node_connectivity(flow_func=None):
+            r"""Returns the average connectivity of a graph G.
+
+            The average connectivity `\bar{\kappa}` of a graph G is the average
+            of local node connectivity over all pairs of the nx_graph nodes.
+
+            https://networkx.org/documentation/stable/_modules/networkx/algorithms/connectivity/connectivity.html#average_node_connectivity
+
+            Parameters
+            ----------
+            :param flow_func : Function
+                A function for computing the maximum flow between a pair of nodes.
+                The function has to accept at least three parameters: a Digraph,
+                a source node, and a target node. And return a residual network
+                that follows NetworkX conventions (see: meth:`maximum_flow` for
+                details). If flow_func is None, the default maximum flow function
+                (:meth:`edmonds_karp`) is used. See :meth:`local_node_connectivity`
+                for details. The choice of the default function may change from
+                version to version and should not be relied on. Default value: None.
+
+            Returns
+            -------
+            K : float
+                Average node connectivity
+
+            References
+            ----------
+            [1]  Beineke, L., O. Oellermann, and r_network. Pippert (2002). The average
+                    connectivity of a graph. Discrete mathematics 252(1-3), 31-45.
+                    https://www.sciencedirect.com/science/article/pii/S0012365X01001807
 
-        The average connectivity of a graph G is the average
-        of local node connectivity over all pairs of the Graph (G) nodes.
+            """
 
-        Parameters
-        ---------
-        :param nx_graph: NetworkX graph object.
-        """
-        from .c_lang import sgt_c_module as sgt
+            if nx_graph.is_directed():
+                iter_func = itertools.permutations
+            else:
+                iter_func = itertools.combinations
+
+            # Reuse the auxiliary digraph and the residual network
+            a_digraph = nx.algorithms.connectivity.build_auxiliary_node_connectivity(nx_graph)
+            r_network = nx.algorithms.flow.build_residual_network(a_digraph, "capacity")
+            # kwargs = {"flow_func": flow_func, "auxiliary": a_digraph, "residual": r_network}
+
+            total, count = 0, 0
+            with multiprocessing.Pool() as pool:
+                items = [(nx_graph, u, v, flow_func, a_digraph, r_network) for u, v in iter_func(nx_graph, 2)]
+                async_result = pool.starmap_async(nx.algorithms.connectivity.local_node_connectivity, items)
+                for n in async_result.get():
+                    total += n
+                    count += 1
+                    if self.abort:
+                        self.update_status([-1, "Task aborted."])
+                        pool.terminate()
+                        pool.join()
+                        return 0
+                    if n is not None:
+                        total += n
+                        count += 1
+            anc = total / count if count > 0 else 0
+            return anc
+
+        def igraph_average_node_connectivity():
+            r"""
+            Returns the average connectivity of a graph G.
+
+            The average connectivity of a graph G is the average
+            of local node connectivity over all pairs of the Graph (G) nodes.
+            """
 
-        cpu_count = get_num_cores()
-        num_threads = cpu_count if nx.number_of_nodes(nx_graph) < 2000 else cpu_count * 2
-        anc = 0
+            ig_graph = ig.Graph.from_networkx(nx_graph)
+            num_nodes = ig_graph.vcount()
+            total, count = 0, 0
+            with multiprocessing.Pool() as pool:
+                # Prepare all node pairs (i < j)
+                items = [(ig_graph, i, j) for i in range(num_nodes) for j in range(i + 1, num_nodes)]
+                async_result = pool.starmap_async(_worker_vertex_connectivity, items)
+                for n in async_result.get():
+                    if self.abort:
+                        self.update_status([-1, "Task aborted."])
+                        pool.terminate()
+                        pool.join()
+                        return 0
+                    if n is not None:
+                        total += n
+                        count += 1
+            anc = total / count if count > 0 else 0
+            return anc
+
+        def igraph_clang_average_node_connectivity():
+            r"""Returns the average connectivity of a graph G.
+
+            The average connectivity of a graph G is the average
+            of local node connectivity over all pairs of the Graph (G) nodes.
 
-        try:
-            filename, output_location = self.ntwk_p.get_filenames()
-            g_filename = filename + "_graph.txt"
-            graph_file = os.path.join(output_location, g_filename)
-            nx.write_edgelist(nx_graph, graph_file, data=False)
-            anc = sgt.compute_anc(graph_file, num_threads, self.allow_mp)
-        except Exception as err:
-            logging.exception("Computing ANC Error: %s", err, extra={'user': 'SGT Logs'})
-        return anc
+            """
+            from .c_lang import sgt_c_module as sgt
+
+            cpu_count = get_num_cores()
+            num_threads = cpu_count if nx.number_of_nodes(nx_graph) < 2000 else cpu_count * 2
+            anc = 0
+
+            try:
+                filename, output_location = self.ntwk_p.get_filenames()
+                g_filename = filename + "_graph.txt"
+                graph_file = os.path.join(output_location, g_filename)
+                nx.write_edgelist(nx_graph, graph_file, data=False)
+                anc = sgt.compute_anc(graph_file, num_threads, self.allow_mp)
+            except Exception as err:
+                logging.exception("Computing ANC Error: %s", err, extra={'user': 'SGT Logs'})
+            return anc
+
+        if is_graph_connected:
+            # use_igraph = opt_gtc["compute_lang == 'C'"]["value"]
+            if self.use_igraph:
+                # use iGraph Lib in C
+                self.update_status([15, "Using iGraph library..."])
+                try:
+                    avg_node_con = igraph_clang_average_node_connectivity()
+                except ImportError:
+                    avg_node_con = igraph_average_node_connectivity()
+            else:
+                # Use NetworkX Lib in Python
+                self.update_status([15, "Using NetworkX library..."])
+                if self.allow_mp:  # Multi-processing
+                    avg_node_con = nx_average_node_connectivity()
+                else:
+                    avg_node_con = average_node_connectivity(nx_graph)
+            avg_node_con = round(avg_node_con, 5)
+        else:
+            avg_node_con = np.nan
+        return avg_node_con
 
     def compute_graph_conductance(self, graph_obj):
         """

StructuralGT/networks/fiber_network.py

@@ -5,9 +5,9 @@ Builds a graph network from nanoscale microscopy images.
 """
 
 import os
-import igraph
 import itertools
 import numpy as np
+import igraph as ig
 import networkx as nx
 import matplotlib.pyplot as plt
 from PIL import Image, ImageQt
@@ -43,7 +43,7 @@ class FiberNetworkBuilder(ProgressUpdate):
         self.img_ntwk: MatLike | None = None
         self.nx_giant_graph: nx.Graph | None = None
         self.nx_graph: nx.Graph | None = None
-        self.ig_graph: igraph.Graph | None = None
+        self.ig_graph: ig.Graph | None = None
         self.gsd_file: str | None = None
         self.skel_obj: GraphSkeleton | None = None
 
@@ -149,7 +149,7 @@ class FiberNetworkBuilder(ProgressUpdate):
             nx_graph[s][e]['weight'] = wt
             # print(f"{nx_graph[s][e]}\n")
         self.nx_graph = nx_graph
-        self.ig_graph = igraph.Graph.from_networkx(nx_graph)
+        self.ig_graph = ig.Graph.from_networkx(nx_graph)
         return True
 
     def plot_graph_network(self, image_arr: MatLike, giant_only: bool = False, plot_nodes: bool = False, a4_size: bool = False):

{sgtlib-3.4.0.dist-info → sgtlib-3.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sgtlib
-Version: 3.4.0
+Version: 3.4.1
 Summary: A software tool for graph theory analysis of microscopy images.
 Author-email: Dickson Owuor <owuordickson@gmail.com>, "Drew A. Vecchio" <vecdrew@umich.edu>, Kody Whisnant <kgwhis@umich.edu>, Alain Kadar <alaink@umich.edu>, Xiong Ye Xiao <xiongyex@usc.edu>, Nicholas Kotov <kotov@umich.edu>
 Maintainer-email: Dickson Owuor <owuordickson@gmail.com>

{sgtlib-3.4.0.dist-info → sgtlib-3.4.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-StructuralGT/__init__.py,sha256=8O4pI5ydEdxVMuojfGLzMWBjt7dVw2shSmAmw52F9tg,1254
+StructuralGT/__init__.py,sha256=UoEP1e5QcjHqzVbt7cUCTL1rRksz3Qsze5OTmSAzeZo,1254
 StructuralGT/entrypoints.py,sha256=s2upsOVsy9zsoorxiZXaZKiLw7fUOQwHjwup3C089Hs,1413
 StructuralGT/modules.py,sha256=CYudBMwP70cRFWj_Dppr_Kdc08V_-9wWKVd48bEHkS0,743
 StructuralGT/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -50,15 +50,13 @@ StructuralGT/apps/sgt_qml/widgets/RescaleControlWidget.qml,sha256=qb6fXok5C1HJjb
 StructuralGT/apps/sgt_qml/widgets/RibbonWidget.qml,sha256=POaPwXh7vE4UwU82x-80BuI2625FLWbmJQsZliy618w,13990
 StructuralGT/apps/sgt_qml/widgets/StatusBarWidget.qml,sha256=YRTSg_4aYA3FO69wT1NnX0Ri_qRx3AHhVrS1n3pVwd4,5969
 StructuralGT/compute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-StructuralGT/compute/graph_analyzer.py,sha256=E2vIaIcApy3VI7gM2rLZ30X8SGtOhzhEkVufMcL-ngA,69859
-StructuralGT/compute/c_lang/sgt_base.c,sha256=VFgwVDALjWl_zAP5NqNwG5pLv6no91_93RYPziHT2hY,1953
-StructuralGT/compute/c_lang/sgtmodule.c,sha256=85VhQCxNow49yslayaCnCFwseS6vXVvJ77RjypkHG1o,5492
+StructuralGT/compute/graph_analyzer.py,sha256=JeUlfeC0phR5JqAqDXAhrUq8amDXNekcIYfvbIUl0q8,72274
 StructuralGT/compute/c_lang/include/sgt_base.h,sha256=jkCpNy_01bSKk_ay6_1TilNhribMmw-p8r8FRhamstM,530
 StructuralGT/imaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 StructuralGT/imaging/base_image.py,sha256=Cc4xeVOxpID6SukVolYtD6OiEQ4tsUGQ4mYjE3QF_2E,16555
 StructuralGT/imaging/image_processor.py,sha256=dElOT51scHbEwsRpfnUUbLQ68twiGAhALgxcqTJBzzM,32878
 StructuralGT/networks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-StructuralGT/networks/fiber_network.py,sha256=Sno9fD5JsdhB0hLsi6CM7EPRKZAuxnbWBTwkhlkc8AA,20060
+StructuralGT/networks/fiber_network.py,sha256=dr-JCfAGi52Lkcn_L4bT1939hXwg-Jp9-90VHMv324I,20058
 StructuralGT/networks/graph_skeleton.py,sha256=_uWDvoHG4Pu-iKIRbIx0FyYqkiQZDk73md9-bOnWswQ,19246
 StructuralGT/networks/sknw_mod.py,sha256=rBLdBmiawj1eURGKreuUJjKeEg5v76WNHkNxVEZhQWY,5542
 StructuralGT/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -66,9 +64,9 @@ StructuralGT/utils/config_loader.py,sha256=8px8iGOFCGz8qIZCfyGuAFfvvaVdOjogf9PqS
 StructuralGT/utils/configs.ini,sha256=sKPsAd15_YubgGhLMVuse1JRuU7S6bFYjLbzkuoD5JI,2326
 StructuralGT/utils/progress_update.py,sha256=9X_9mGLgTMF5dDSTNKpELQcmFv8r1wz6YZQCqy4tCl8,1621
 StructuralGT/utils/sgt_utils.py,sha256=0vg7I4P6PIao_H8-KYgkCJ6TM9eESW-RwGZB4sGgCI4,9109
-sgtlib-3.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-sgtlib-3.4.0.dist-info/METADATA,sha256=KLud3ApS4KMRC6hYaHiseM1P4kQ57Oy8EhNvQ9B9ANU,45278
-sgtlib-3.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sgtlib-3.4.0.dist-info/entry_points.txt,sha256=zY3v_U9Qi4L965BPrURXn84yF_TxdKDZI3VcTUbTh0M,120
-sgtlib-3.4.0.dist-info/top_level.txt,sha256=daVVcqfvgGeWXFnHArFOFbRmtWxL93fxmZjF19Sg69I,13
-sgtlib-3.4.0.dist-info/RECORD,,
+sgtlib-3.4.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+sgtlib-3.4.1.dist-info/METADATA,sha256=VPPMOWhLdj4PB4XvU5Gj5CN_-UJTQx-NJZw0Gv_UIGk,45278
+sgtlib-3.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sgtlib-3.4.1.dist-info/entry_points.txt,sha256=zY3v_U9Qi4L965BPrURXn84yF_TxdKDZI3VcTUbTh0M,120
+sgtlib-3.4.1.dist-info/top_level.txt,sha256=daVVcqfvgGeWXFnHArFOFbRmtWxL93fxmZjF19Sg69I,13
+sgtlib-3.4.1.dist-info/RECORD,,

StructuralGT/compute/c_lang/sgt_base.c

@@ -1,61 +0,0 @@
-//#define _POSIX_C_SOURCE 200809L  // Linux
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-//#include "sgt_base.h"
-#include "include/sgt_base.h"
-
-// Function to compute Local Node Connectivity
-void* compute_lnc(void *arg) {
-    ThreadArgsLNC *args = (ThreadArgsLNC*)arg;
-    igraph_integer_t lnc;
-
-    igraph_st_vertex_connectivity(args->graph, &lnc, args->i, args->j, IGRAPH_VCONN_NEI_NEGATIVE);
-
-    // Update shared data under mutex lock
-    pthread_mutex_lock(args->mutex);
-    if (lnc != -1){
-        *(args->total_nc) += lnc;
-        *(args->total_count) += 1;
-        //printf("got %d\n", lnc);
-        //printf("NC:%d Count:%d \n", *(args->total_nc), *(args->total_count));
-    }
-    pthread_mutex_unlock(args->mutex);
-    
-    pthread_exit(NULL);
-}
-
-// Function to convert string representation of adjacency matrix to 2D matrix
-igraph_matrix_t* str_to_matrix(char* str_adj_mat, igraph_integer_t num_vertices) {
-    // Allocate memory for the matrix
-    igraph_matrix_t* mat = (igraph_matrix_t*)malloc(sizeof(igraph_matrix_t));
-    if (!mat) {
-        fprintf(stderr, "Failed to allocate memory for matrix structure\n");
-        exit(EXIT_FAILURE);
-    }
-    igraph_matrix_init(mat, num_vertices, num_vertices);
-
-    // Parse string and populate matrix
-    char* token;
-    char* nextToken;
-    const char delimiters[] = ",";
-
-    // Get the first token
-    // strtok_r - MacOs
-    //token = strtok_r(str_adj_mat, delimiters, &nextToken);
-    token = strtok_s(str_adj_mat, delimiters, &nextToken);
-
-    // Iterate through the remaining tokens
-    for (igraph_integer_t i = 0; i < num_vertices; i++) {
-        for (igraph_integer_t j = 0; j < num_vertices; j++) {
-            MATRIX(*mat, i, j) = atoi(token);
-            // Get the next token
-            // strtok_r - MacOs
-            //token = strtok_r(NULL, delimiters, &nextToken);
-            token = strtok_s(NULL, delimiters, &nextToken);
-        }
-    }
-
-    return mat;
-}
-

StructuralGT/compute/c_lang/sgtmodule.c

@@ -1,183 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#define PY_SSIZE_T_CLEAN
-#include <Python.h>
-//#include "sgt_base.h"
-#include "include/sgt_base.h"
-
-
-static PyObject *ErrorObject;
-static PyObject *
-compute_anc(PyObject *self, PyObject *args)
-{
-    int num_cpus;
-    int allow_mp;
-    char *f_name;
-
-    // Consider passing graph as String
-    if (!PyArg_ParseTuple(args, "sii:compute_anc", &f_name, &num_cpus, &allow_mp)){
-        return NULL;
-    }
-
-	/*if ( f_name == ''){
-    	PyErr_SetString(ErrorObject, "Unable to retrieve graph.");
-    	return NULL;
-  	}*/
-
-	if ( num_cpus <= 0 || allow_mp < 0){
-    	PyErr_SetString(ErrorObject, "Invalid CPU parameters.");
-    	return NULL;
-  	}
-
-    // Declare required variables
-  	FILE *file;
-
-  	igraph_t graph;
-	igraph_integer_t num_nodes;
-    igraph_integer_t count_nc = 0;
-    igraph_integer_t sum_nc = 0;
-    igraph_real_t anc = 0;
-
-    // Open the file containing the serialized graph
-    file = fopen(f_name, "r");
-    // Read the graph from the file
-    igraph_read_graph_edgelist(&graph, file, 0, IGRAPH_UNDIRECTED);
-    fclose(file);
-    // printf("Nodes: %d\nEdges: %d\n", (int)igraph_vcount(&graph), (int)igraph_ecount(&graph));
-
-	num_nodes = igraph_vcount(&graph);
-	if (allow_mp == 0){
-        printf("Using single processing\n");
-        igraph_integer_t lnc;
-        for (igraph_integer_t i=0; i<num_nodes; i++) {
-            for (igraph_integer_t j=i+1; j<num_nodes; j++){
-                igraph_st_vertex_connectivity(&graph, &lnc, i, j, IGRAPH_VCONN_NEI_NEGATIVE);
-                if (lnc == -1) { continue; }
-                sum_nc += lnc;
-                count_nc += 1;
-            }
-        }
-
-    }
-    else {
-        printf("Using multiprocessing\n");
-        // Initialize mutex
-        pthread_mutex_t mutex;
-        pthread_mutex_init(&mutex, NULL);
-
-        // Create thread pool
-        const int MAX_THREAD_COUNT = num_cpus;
-
-        // Allocate memory for threads and args arrays
-        pthread_t *threads = (pthread_t *)malloc(MAX_THREAD_COUNT * sizeof(pthread_t));
-        ThreadArgsLNC *args = (ThreadArgsLNC *)malloc(MAX_THREAD_COUNT * sizeof(ThreadArgsLNC));
-
-        if (threads == NULL || args == NULL) {
-            PyErr_SetString(ErrorObject, "Memory allocation failed\n");
-    	    return NULL;
-        }
-
-        // Initialize thread pool
-        for (int i = 0; i < MAX_THREAD_COUNT; i++) {
-            args[i].graph = &graph;
-            args[i].mutex = &mutex;
-            args[i].total_nc = &sum_nc;
-            args[i].total_count = &count_nc;
-        }
-
-        // Create threads for computing LNC
-        int idx = 0;
-        int thread_count = 0;
-        for (igraph_integer_t i = 0; i < num_nodes; i++) {
-            for (igraph_integer_t j = i + 1; j < num_nodes; j++) {
-                idx = (int)(thread_count % MAX_THREAD_COUNT);
-                if (thread_count >= MAX_THREAD_COUNT) {
-                    // Wait for a thread to finish before starting a new one
-                    pthread_join(threads[idx], NULL);
-                    thread_count++;
-                }
-                args[idx].i = (int)i;
-                args[idx].j = (int)j;
-                pthread_create(&threads[idx], NULL, compute_lnc, &args[idx]);
-                thread_count++;
-                // printf("thread %d running...\n", (idx));
-            }
-        }
-
-        // Join threads
-        for (int i = 0; i < MAX_THREAD_COUNT && i < thread_count; i++) {
-            pthread_join(threads[i], NULL);
-        }
-
-        // Destroy mutex
-        pthread_mutex_destroy(&mutex);
-        // Free dynamically allocated memory
-        free(threads);
-        free(args);
-    }
-
-    // Compute ANC
-    anc = (float) sum_nc / count_nc;
-
-    // Destroy graph
-    igraph_destroy(&graph);
-
-    return PyFloat_FromDouble((double) anc);
-
-}
-static char compute_anc_doc[] =
-"A C method that uses iGraph library to compute average node connectivity of a graph.\n"
-"\n"
-"Args:\n"
-"   file (string): CSV file with edge list of graph A.\n"
-"   cpus (int): number of available CPUs.\n"
-"   mp (int): allow multi-processing (0: No, 1: Yes).\n"
-"\n"
-"Returns:\n"
-"   ANC (float): Average Node Connectivity as a float value.\n";
-
-
-static char sgt_doc[] =
-"A C language module leveraging the iGraph library to compute Graph Theory (GT) metrics,"
-"enhanced with multi-threading capabilities for accelerated computation.\n";
-
-/* Method Table: ist of functions defined in the module */
-static PyMethodDef sgt_methods[] = {
-    {"compute_anc", compute_anc, METH_VARARGS, compute_anc_doc },
-    //{"compute_lnc", compute_lnc, METH_VARARGS, "Compute local node connectivity." },
-	{NULL, NULL, 0, NULL}        /* Sentinel */
-};
-
-/* Create module */
-static struct PyModuleDef sgt_c_module = {
-    PyModuleDef_HEAD_INIT,
-    "sgt_c_module",   /* name of module */
-    sgt_doc, /* module documentation, may be NULL */
-    -1,       /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */
-    sgt_methods
-};
-
-/* Initialization function for the module */
-PyMODINIT_FUNC
-PyInit_sgt_c_module(void)
-{
-    PyObject *m;
-
-    m = PyModule_Create(&sgt_c_module);
-    if (m == NULL)
-        return NULL;
-
-    ErrorObject = PyErr_NewException("sgt_c_module.error", NULL, NULL);
-    Py_XINCREF(ErrorObject);
-    if (PyModule_AddObject(m, "error", ErrorObject) < 0) {
-        Py_XDECREF(ErrorObject);
-        Py_CLEAR(ErrorObject);
-        Py_DECREF(m);
-        return NULL;
-    }
-
-    return m;
-}
-