topologicpy 0.7.97__py3-none-any.whl → 0.7.99__py3-none-any.whl

topologicpy/Graph.py

@@ -1240,9 +1240,9 @@ class Graph:
         return bot_graph.serialize(format=format)
 
     @staticmethod
-    def BetweennessCentrality(graph, key: str = "betweenness_centrality", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def BetweennessCentrality(graph, key: str = "betweenness_centrality", method="vertex", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
         """
-            Returns the betweenness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
+            Returns the betweenness centrality of the input graph. The order of the returned list is the same as the order of vertices/edges. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
         Parameters
         ----------
@@ -1250,6 +1250,8 @@ class Graph:
             The input graph.
         key : str , optional
             The dictionary key under which to store the betweeness centrality score. The default is "betweenness_centrality".
+        method : str , optional
+            The method of computing the betweenness centrality. The options are "vertex" or "edge". The default is "vertex".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -1276,7 +1278,7 @@ class Graph:
                 shortest_paths[path[-1]].append(path)
             return shortest_paths
 
-        def calculate_betweenness():
+        def calculate_vertex_betweenness():
             betweenness = {v: 0.0 for v in py_graph}
             for s in py_graph:
                 shortest_paths = shortest_paths_count(s)
@@ -1291,6 +1293,56 @@ class Graph:
                         betweenness[v] += dependency[v]
             return betweenness
         
+        def calculate_edge_betweenness(graph_adj_matrix):
+            n = len(graph_adj_matrix)
+            edge_betweenness_scores = {}
+
+            # Iterate over all node pairs as source and target nodes
+            for source in range(n):
+                # Initialize the 'distance' and 'predecessors' for each node
+                distance = [-1] * n
+                predecessors = [[] for _ in range(n)]
+                distance[source] = 0
+                stack = []
+                queue = [source]
+
+                # Breadth-first search to find shortest paths
+                while queue:
+                    current_node = queue.pop(0)
+                    stack.append(current_node)
+                    for neighbor in range(n):
+                        if graph_adj_matrix[current_node][neighbor] == 1:
+                            if distance[neighbor] == -1:  # First time visiting neighbor
+                                distance[neighbor] = distance[current_node] + 1
+                                queue.append(neighbor)
+                            if distance[neighbor] == distance[current_node] + 1:  # Shortest path
+                                predecessors[neighbor].append(current_node)
+
+                # Initialize the dependency values for each node
+                dependency = [0] * n
+
+                # Process the nodes in reverse order of discovery
+                while stack:
+                    current_node = stack.pop()
+                    for pred in predecessors[current_node]:
+                        dependency[pred] += (1 + dependency[current_node]) / len(predecessors[current_node])
+
+                        # Update edge betweenness scores
+                        if pred < current_node:
+                            edge = (pred, current_node)
+                        else:
+                            edge = (current_node, pred)
+                        
+                        if edge not in edge_betweenness_scores:
+                            edge_betweenness_scores[edge] = 0
+                        edge_betweenness_scores[edge] += dependency[current_node]
+
+            # Normalize edge betweenness scores by dividing by 2 (since each edge is counted twice)
+            for edge in edge_betweenness_scores:
+                edge_betweenness_scores[edge] /= 2
+
+            return edge_betweenness_scores
+        
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
 
@@ -1299,39 +1351,145 @@ class Graph:
                 print("Graph.BetweenessCentrality - Error: The input graph is not a valid graph. Returning None.")
             return None
         
-        vertices = Graph.Vertices(graph)
+        if "v" in method.lower():
+            vertices = Graph.Vertices(graph)
 
-        if len(vertices) < 1:
-            if not silent:
-                print("Graph.BetweenessCentrality - Error: The input graph does not contain valid vertices. Returning None.")
-            return None
-        if len(vertices) == 1:
-            d = Topology.Dictionary(vertices[0])
-            d = Dictionary.SetValueAtKey(d, key, 1.0)
-            vertices[0] = Topology.SetDictionary(vertices[0], d)
-            return [1.0]
-        
-        py_graph = Graph.AdjacencyDictionary(graph)
-        betweenness = calculate_betweenness()
-        for v in betweenness:
-            betweenness[v] /= 2.0  # Each shortest path is counted twice
+            if len(vertices) < 1:
+                if not silent:
+                    print("Graph.BetweenessCentrality - Error: The input graph does not contain valid vertices. Returning None.")
+                return None
+            if len(vertices) == 1:
+                d = Topology.Dictionary(vertices[0])
+                d = Dictionary.SetValueAtKey(d, key, 1.0)
+                vertices[0] = Topology.SetDictionary(vertices[0], d)
+                return [1.0]
+            
+            py_graph = Graph.AdjacencyDictionary(graph)
+            vertex_betweenness = calculate_vertex_betweenness()
+            for v in vertex_betweenness:
+                vertex_betweenness[v] /= 2.0  # Each shortest path is counted twice
+
+            min_betweenness = min(vertex_betweenness.values())
+            max_betweenness = max(vertex_betweenness.values())
+            if (max_betweenness - min_betweenness) > 0:
+                for v in vertex_betweenness:
+                    vertex_betweenness[v] = (vertex_betweenness[v] - min_betweenness)/ (max_betweenness - min_betweenness)  # Normalize to [0, 1]
+            
+            
+            vertex_betweenness_scores = [0]*len(vertices)
+            for i, score in vertex_betweenness.items():
+                vertex = vertices[int(i)]
+                d = Topology.Dictionary(vertex)
+                d = Dictionary.SetValueAtKey(d, key, round(score, mantissa))
+                vertex = Topology.SetDictionary(vertex, d)
+                vertex_betweenness_scores[int(i)] = round(score, mantissa)
+            
+            return vertex_betweenness_scores
+        else:
+            graph_edges = Graph.Edges(graph)
+            adj_matrix = Graph.AdjacencyMatrix(graph)
+            meshData = Graph.MeshData(graph)
+            edges = meshData["edges"]
+            if len(graph_edges) < 1:
+                if not silent:
+                    print("Graph.BetweenessCentrality - Error: The input graph does not contain any edges. Returning None.")
+                return None
+            if len(graph_edges) == 1:
+                d = Topology.Dictionary(graph_edges[0])
+                d = Dictionary.SetValueAtKey(d, key, 1.0)
+                graph_edges[0] = Topology.SetDictionary(graph_edges[0], d)
+                return [1.0]
+            
+            edge_betweenness = calculate_edge_betweenness(adj_matrix)
+            keys = list(edge_betweenness.keys())
+            values = list(edge_betweenness.values())
+            min_value = min(values)
+            max_value = max(values)
+            edge_betweenness_scores = []
+            for i, edge in enumerate(edges):
+                u,v = edge
+                if (u,v) in keys:
+                    score = edge_betweenness[(u,v)]
+                elif (v,u) in keys:
+                    score = edge_betweenness[(v,u)]
+                else:
+                    score = 0
+                score = (score - min_value)/(max_value - min_value)
+                edge_betweenness_scores.append(round(score, mantissa))
+                d = Topology.Dictionary(graph_edges[i])
+                d = Dictionary.SetValueAtKey(d, key, round(score, mantissa))
+                graph_edges[i] = Topology.SetDictionary(graph_edges[i], d)
+            return edge_betweenness_scores
 
-        max_betweenness = max(betweenness.values())
-        if max_betweenness > 0:
-            for v in betweenness:
-                betweenness[v] /= max_betweenness  # Normalize to [0, 1]
-        
-        
-        return_betweenness = [0]*len(vertices)
-        for i, v in betweenness.items():
-            vertex = vertices[int(i)]
-            d = Topology.Dictionary(vertex)
-            d = Dictionary.SetValueAtKey(d, key, round(v, mantissa))
-            vertex = Topology.SetDictionary(vertex, d)
-            return_betweenness[int(i)] = v
-        
-        return return_betweenness
+    @staticmethod
+    def BetweennessPartition(graph, n=2, m=10, key="partition", tolerance=0.0001, silent=False):
+        """
+        Computes a partition of the input graph based on the edge betweenness method. See https://en.wikipedia.org/wiki/Graph_partition.
 
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        n : int , optional
+            The desired number of partitions when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 2.
+        m : int , optional
+            The desired maximum number of tries to partition the graph when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 10.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the parition number. The default is "partition".
+            Valid partition numbers start from 1. Cut edges receive a partition number of 0.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+        from topologicpy.Dictionary import Dictionary
+
+        edge_scores = Graph.BetweennessCentrality(graph, method="edge")
+        graph_edges = Graph.Edges(graph)
+
+        graph_edges = Helper.Sort(graph_edges, edge_scores)
+        graph_edges.reverse()
+        cut_edges = []
+        components = 1
+        tries = 0
+        while components < n and tries < m:
+            components = len(Graph.ConnectedComponents(graph, key=key, tolerance=tolerance, silent=silent))
+            if components == n:
+                if not silent:
+                    print("Graph.BetweennessPartition - Warning: The input graph is already partitioned into partitions that are equal in number to the desired number of partitions.")
+                return graph
+            elif components > n:
+                if not silent:
+                    print("Graph.BetweennessPartition - Warning: The input graph is already partitioned into partitions that are greater in number than the desired number of partitions.")
+                return graph
+            elif len(graph_edges) < 1:
+                components = n
+            else:
+                edge = graph_edges[0]
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, key, 0) # 0 indicates a cut edge
+                edge = Topology.SetDictionary(edge, d)
+                cut_edges.append(edge)
+                graph = Graph.RemoveEdge(graph, edge, tolerance=tolerance)
+                graph_edges = graph_edges[1:]
+                components = len(Graph.ConnectedComponents(graph, key=key, tolerance=tolerance, silent=silent))
+            tries += 1
+            if tries == m:
+                if not silent:
+                    print("Graph.Partition - Warning: Reached the maximum number of tries.")
+        return_vertices = Graph.Vertices(graph)
+        return_edges = Graph.Edges(graph) + cut_edges
+        return_graph = Graph.ByVerticesEdges(return_vertices, return_edges)
+        return return_graph
+    
     @staticmethod
     def Bridges(graph, key: str = "bridge", silent: bool = False):
         """
@@ -1345,59 +1503,91 @@ class Graph:
             The edge dictionary key under which to store the bridge status. 0 means the edge is NOT a bridge. 1 means that the edge IS a bridge. The default is "bridge".
         silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
-        
+
         Returns
         -------
         list
             The list of bridge edges in the input graph.
-
         """
-        import os
-        import warnings
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
 
-        try:
-            import igraph as ig
-        except:
-            print("Graph.Bridges - Installing required pyhon-igraph library.")
-            try:
-                os.system("pip install python-igraph")
-            except:
-                os.system("pip install python-igraph --user")
-            try:
-                import igraph as ig
-                print("Graph.Bridges - python-igraph library installed correctly.")
-            except:
-                warnings.warn("Graph.Bridges - Error: Could not import python-igraph. Please install manually.")
-        
         if not Topology.IsInstance(graph, "graph"):
             if not silent:
                 print("Graph.Bridges - Error: The input graph parameter is not a valid topologic graph. Returning None")
             return None
 
-        edges = Graph.Edges(graph)
-        if len(edges) < 1:
-            return []
-        if len(edges) == 1:
+        graph_edges = Graph.Edges(graph)
+        for edge in graph_edges:
             d = Topology.Dictionary(edge)
-            d = Dictionary.SetValueAtKey(d, key, 1)
+            d = Dictionary.SetValueAtKey(d, key, 0)
             edge = Topology.SetDictionary(edge, d)
-            return [edge]
         mesh_data = Graph.MeshData(graph)
-        graph_edges = mesh_data['edges']
-        ig_graph = ig.Graph(edges=graph_edges)
+        mesh_edges = mesh_data['edges']
 
-        bridges = ig_graph.bridges()
+        # Get adjacency dictionary
+        adjacency_dict = Graph.AdjacencyDictionary(graph)
+        if not adjacency_dict:
+            if not silent:
+                print("Graph.Bridges - Error: Failed to retrieve adjacency dictionary. Returning None")
+            return None
+
+        # Helper function to perform DFS and find bridges
+        def dfs(vertex, parent, time, low, disc, visited, adjacency_dict, bridges, edge_map):
+            visited[int(vertex)] = True
+            disc[int(vertex)] = low[int(vertex)] = time[0]
+            time[0] += 1
+            for neighbor in adjacency_dict[vertex]:
+                if not visited[int(neighbor)]:
+                    dfs(neighbor, vertex, time, low, disc, visited, adjacency_dict, bridges, edge_map)
+                    low[int(vertex)] = min(low[int(vertex)], low[int(neighbor)])
+                    
+                    # Check if edge is a bridge
+                    if low[int(neighbor)] > disc[int(vertex)]:
+                        bridges.add((vertex, neighbor))
+                elif neighbor != parent:
+                    low[int(vertex)] = min(low[int(vertex)], disc[int(neighbor)])
+
+        # Prepare adjacency list and edge mapping
+        vertices = list(adjacency_dict.keys())
+        num_vertices = len(vertices)
+        visited = [False] * num_vertices
+        disc = [-1] * num_vertices
+        low = [-1] * num_vertices
+        time = [0]
+        bridges = set()
+
+        # Map edges to indices
+        edge_map = {}
+        index = 0
+        for vertex, neighbors in adjacency_dict.items():
+            for neighbor in neighbors:
+                if (neighbor, vertex) not in edge_map:  # Avoid duplicating edges in undirected graphs
+                    edge_map[(vertex, neighbor)] = index
+                    index += 1
+
+        # Run DFS from all unvisited vertices
+        for i, vertex in enumerate(vertices):
+            if not visited[i]:
+                dfs(vertex, -1, time, low, disc, visited, adjacency_dict, bridges, edge_map)
+
+        # Mark bridges in the edges' dictionaries
         bridge_edges = []
-        for i, edge in enumerate(edges):
+        for edge in bridges:
+            i, j = edge
+            i = int(i)
+            j = int(j)
+            try:
+                edge_index = mesh_edges.index([i,j])
+            except:
+                edge_index = mesh_edges.index([j,i])
+            bridge_edges.append(graph_edges[edge_index])
+        for edge in bridge_edges:
             d = Topology.Dictionary(edge)
-            if i in bridges:
-                d = Dictionary.SetValueAtKey(d, key, 1)
-                bridge_edges.append(edge)
-            else:
-                d = Dictionary.SetValueAtKey(d, key, 0)
+            d = Dictionary.SetValueAtKey(d, key, 1)
             edge = Topology.SetDictionary(edge, d)
+
         return bridge_edges
 
     @staticmethod
@@ -1486,7 +1676,8 @@ class Graph:
         for i in range(len(adjacencyMatrix)):
             x, y, z = random.uniform(xMin,xMax), random.uniform(yMin,yMax), random.uniform(zMin,zMax)
             v = Vertex.ByCoordinates(x, y, z)
-            v = Topology.SetDictionary(v, dictionaries[i])
+            if isinstance(dictionaries, list):
+                v = Topology.SetDictionary(v, dictionaries[i])
             vertices.append(v)
 
         # Create the graph using vertices and edges
@@ -4153,6 +4344,82 @@ class Graph:
                 v = Topology.SetDictionary(v, d)
         return graph
     
+    @staticmethod
+    def Complement(graph, tolerance=0.0001, silent=False):
+        """
+        Creates the complement graph of the input graph. See https://en.wikipedia.org/wiki/Complement_graph
+
+        Parameters
+        ----------
+        graph : topologicpy.Graph
+            The input topologic graph.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologicpy.Graph
+            The created complement topologic graph.
+
+        """
+        def complement_graph(adj_dict):
+            """
+            Creates the complement graph from an input adjacency dictionary.
+
+            Parameters:
+                adj_dict (dict): The adjacency dictionary where keys are nodes and 
+                                values are lists of connected nodes.
+
+            Returns:
+                list of tuples: A list of edge index tuples representing the complement graph.
+            """
+            # Get all nodes in the graph
+            nodes = list(adj_dict.keys())
+            # Initialize a set to store edges of the complement graph
+            complement_edges = set()
+            # Convert adjacency dictionary to a set of existing edges
+            existing_edges = set()
+            for node, neighbors in adj_dict.items():
+                for neighbor in neighbors:
+                    # Add the edge as an ordered tuple to ensure no duplicates
+                    existing_edges.add(tuple(sorted((node, neighbor))))
+            # Generate all possible edges and check if they exist in the original graph
+            for i, node1 in enumerate(nodes):
+                for j in range(i + 1, len(nodes)):
+                    node2 = nodes[j]
+                    edge = tuple(sorted((node1, node2)))
+                    # Add the edge if it's not in the original graph
+                    if edge not in existing_edges:
+                        complement_edges.add(edge)
+            # Return the complement edges as a sorted list of tuples
+            return sorted(complement_edges)
+    
+        from topologicpy.Graph import Graph
+        from topologicpy.Edge import Edge
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.Complement - Error: The input graph parameter is not a valid topologic graph. Returning None.")
+            return None
+        adj_dict = Graph.AdjacencyDictionary(graph)
+        py_edges = complement_graph(adj_dict)
+        vertices = Graph.Vertices(graph)
+        adjusted_vertices = Vertex.Separate(vertices, minDistance=tolerance)
+        edges = []
+        for py_edge in py_edges:
+            start, end = py_edge
+            sv = adjusted_vertices[int(start)]
+            ev = adjusted_vertices[int(end)]
+            edge = Edge.ByVertices(sv, ev, tolerance=tolerance, silent=silent)
+            if Topology.IsInstance(edge, "edge"):
+                edges.append(edge)    
+        return_graph = Graph.ByVerticesEdges(adjusted_vertices, edges)
+        return return_graph
+
     @staticmethod
     def Complete(graph, silent: bool = False):
         """
@@ -4196,7 +4463,7 @@ class Graph:
         return Graph.ByVerticesEdges(vertices, edges)
 
     @staticmethod
-    def ConnectedComponents(graph, tolerance: float = 0.0001, silent: bool = False):
+    def ConnectedComponents(graph, key: str = "component", tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the connected components (islands) of the input graph.
 
@@ -4204,6 +4471,8 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the component number. The default is "component".
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -4249,23 +4518,36 @@ class Graph:
         labelKey = "__label__"
         lengths = [] #List of lengths to sort the list of components by number of their vertices
         vertices = Graph.Vertices(graph)
+        vertex_map = {}
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, labelKey, i)
+            v = Topology.SetDictionary(v, d)
+            vertex_map[i] = v
         g_dict = Graph.AdjacencyDictionary(graph, vertexLabelKey=labelKey)
         components = find_connected_components(g_dict)
         return_components = []
-        for component in components:
+        for i, component in enumerate(components):
             i_verts = []
-            for v in component:        
-                vert = Topology.Filter(vertices, searchType="equal to", key=labelKey, value=v)['filtered'][0]
+            for v in component:
+                vert = vertex_map[v]
                 d = Topology.Dictionary(vert)
                 d = Dictionary.RemoveKey(d, labelKey)
+                d = Dictionary.SetValueAtKey(d, key, i+1)
                 vert = Topology.SetDictionary(vert, d)
                 i_verts.append(vert)
-            i_edges = Graph.Edges(graph, i_verts)
-            lengths.append(len(i_verts))
-            g_component = Graph.ByVerticesEdges(i_verts, i_edges)
-            return_components.append(g_component)
-        return_components = Helper.Sort(return_components, lengths)
-        return_components.reverse()
+            if len(i_verts) > 0:
+                i_edges = Graph.Edges(graph, i_verts)
+                for i_edge in i_edges:
+                    d = Topology.Dictionary(i_edge)
+                    d = Dictionary.SetValueAtKey(d, key, i+1)
+                    i_edge = Topology.SetDictionary(i_edge, d)
+                lengths.append(len(i_verts))
+                g_component = Graph.ByVerticesEdges(i_verts, i_edges)
+                return_components.append(g_component)
+        if len(return_components) > 0:
+            return_components = Helper.Sort(return_components, lengths)
+            return_components.reverse()
         return return_components
 
     @staticmethod
@@ -4460,17 +4742,16 @@ class Graph:
             return centralities
 
     @staticmethod
-    def Community(graph, key: str = "community", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+    def Community(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Computes the best community partition of the input graph based on the Louvain method. See https://en.wikipedia.org/wiki/Louvain_method.
-        This method depends on NetworkX and the python-louvain libraries
 
         Parameters
         ----------
         graph : topologicp.Graph
             The input topologic graph.
         key : str , optional
-            The dictionary key under which to store the closeness centrality score. The default is "community".
+            The dictionary key under which to store the partition number. The default is "partition".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -4480,9 +4761,38 @@ class Graph:
         Returns
         -------
         topologicpy.Graph
-            The created topologic graph.
+            The partitioned topologic graph.
+
+        """
+        if not silent:
+            print("Graph.Community - Warning: This method is deprectated. Please use Graph.CommunityPartition instead.")
+        return Graph.CommunityPartition(graph=graph, key=key, mantissa=mantissa, tolerance=tolerance, silent=silent)
+    
+    @staticmethod
+    def CommunityPartition(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Computes the best community partition of the input graph based on the Louvain method. See https://en.wikipedia.org/wiki/Louvain_method.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        key : str , optional
+            The dictionary key under which to store the partition number. The default is "partition".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
 
         """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
         import os
@@ -4515,13 +4825,39 @@ class Graph:
         communities = ig_graph.community_multilevel()
 
         # Get the list of communities sorted same as vertices
-        community_list = communities.membership
+        partition_list = communities.membership
         vertices = Graph.Vertices(graph)
         for i, v in enumerate(vertices):
             d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, community_list[i])
+            d = Dictionary.SetValueAtKey(d, key, partition_list[i]+1)
             v = Topology.SetDictionary(v, d)
-        return community_list
+        edges = Graph.Edges(graph)
+        if not edges == None:
+            for edge in edges:
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                status_1 = False
+                status_2 = False
+                partition_1 = 0
+                partition_2 = 0
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(sv, v, tolerance=tolerance):
+                        status_1 = True
+                        partition_1 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(ev, v, tolerance=tolerance):
+                        status_2 = True
+                        partition_2 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                partition = 0
+                if status_1 and status_2:
+                    if partition_1 == partition_2:
+                        partition = partition_1
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, key, partition)
+                edge = Topology.SetDictionary(edge, d)
+        return graph
 
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
@@ -4793,6 +5129,28 @@ class Graph:
             scores.append(degree)
         return scores
     
+    @staticmethod
+    def DegreeMatrix(graph):
+        """
+        Returns the degree matrix of the input graph. See https://en.wikipedia.org/wiki/Degree_matrix.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+
+        Returns
+        -------
+        list
+            The degree matrix of the input graph.
+
+        """
+        import numpy as np
+        adj_matrix = Graph.AdjacencyMatrix(g)
+        np_adj_matrix = np.array(adj_matrix)
+        degree_matrix = np.diag(np_adj_matrix.sum(axis=1))
+        return degree_matrix.tolist()
+    
     @staticmethod
     def DegreeSequence(graph):
         """
@@ -6161,6 +6519,111 @@ class Graph:
                 return False
         return False
 
+    @staticmethod
+    def FiedlerVector(graph, mantissa = 6, silent: bool = False):
+        """
+        Computes the Fiedler vector of a graph. See https://en.wikipedia.org/wiki/Algebraic_connectivity.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph
+        mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        list
+            The Fiedler vector (eigenvector corresponding to the second smallest eigenvalue).
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Matrix import Matrix
+        import numpy as np
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.FiedlerVector - Error: The input graph parameter is not a valid graph. Returning None.")
+            
+        laplacian = Graph.Laplacian(graph)
+        eigenvalues, eigenvectors = Matrix.EigenvaluesAndVectors(laplacian, mantissa=mantissa)
+        return eigenvectors[1]
+
+    @staticmethod
+    def FiedlerVectorPartition(graph, key="partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Partitions the input graph based on FiedlerVector method. See https://en.wikipedia.org/wiki/Graph_partition.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the parition number. The default is "partition".
+            Valid partition numbers start from 1. Cut edges receive a partition number of 0.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
+
+        """ 
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge    
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.FiedlerVectorPartition - Error: The input graph parameter is not a valid topologic graph. Returning None.")
+            return None
+
+        fiedler_vector = Graph.FiedlerVector(graph, mantissa=mantissa, silent=silent)
+
+        vertices = Graph.Vertices(graph)
+        for i, f_v in enumerate(fiedler_vector):
+            if f_v >=0:
+                partition = 1
+            else:
+                partition = 2 
+            d = Topology.Dictionary(vertices[i])
+            d = Dictionary.SetValueAtKey(d, key, partition)
+            vertices[i] = Topology.SetDictionary(vertices[i], d)
+        edges = Graph.Edges(graph)
+        if not edges == None:
+            for edge in edges:
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                status_1 = False
+                status_2 = False
+                partition_1 = 0
+                partition_2 = 0
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(sv, v, tolerance=tolerance):
+                        status_1 = True
+                        partition_1 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(ev, v, tolerance=tolerance):
+                        status_2 = True
+                        partition_2 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                partition = 0
+                if status_1 and status_2:
+                    if partition_1 == partition_2:
+                        partition = partition_1
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, key, partition)
+                edge = Topology.SetDictionary(edge, d)
+        return graph
+
     @staticmethod
     def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
@@ -7511,6 +7974,59 @@ class Graph:
             return None
         return graph.IsComplete()
     
+    @staticmethod
+    def IsConnected(graph, vertexA, vertexB, silent: bool = False):
+        """
+        Returns True if the two input vertices are directly connected by an edge. Returns False otherwise.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexA : topologic_core.Vertex
+            The first input vertex.
+        vertexB : topologic_core.Vertex
+            The second input vertex
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        bool
+            True if the input vertices are connected by an edge. False otherwise.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.IsConnected - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        if not Topology.IsInstance(vertexA, "vertex"):
+            if not silent:
+                print("Graph.IsConnected - Error: The input vertexA parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if not Topology.IsInstance(vertexB, "vertex"):
+            if not silent:
+                print("Graph.IsConnected - Error: The input vertexB parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if vertexA == vertexB:
+            if not silent:
+                print("Graph.IsConnected - Warrning: The two input vertices are the same vertex. Returning False.")
+            return False
+        shortest_path = Graph.ShortestPath(graph, vertexA, vertexB)
+        if shortest_path == None:
+            return False
+        else:
+            edges = Topology.Edges(shortest_path)
+            if len(edges) == 1:
+                return True
+            else:
+                return False
+    
     @staticmethod
     def IsErdoesGallai(graph, sequence):
         """
@@ -7777,6 +8293,61 @@ class Graph:
         json_string = json.dumps(json_data, indent=indent, sort_keys=sortKeys)
         return json_string
     
+    def Laplacian(graph, silent: bool = False, normalized: bool = False):
+        """
+        Returns the Laplacian matrix of the input graph. See https://en.wikipedia.org/wiki/Laplacian_matrix.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        normalized : bool , optional
+            If set to True, the returned Laplacian matrix is normalized. The default is False.
+
+        Returns
+        -------
+        list
+            The Laplacian matrix as a nested list.
+        """
+        from topologicpy.Topology import Topology
+        import numpy as np
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.Laplacian - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+
+        # Get vertices of the graph
+        vertices = Graph.Vertices(graph)
+        n = len(vertices)
+
+        # Initialize Laplacian matrix
+        laplacian = np.zeros((n, n))
+
+        # Fill Laplacian matrix
+        for i, v1 in enumerate(vertices):
+            for j, v2 in enumerate(vertices):
+                if i == j:
+                    laplacian[i][j] = float(Graph.VertexDegree(graph, v1))
+                elif Graph.IsConnected(graph, v1, v2):
+                    laplacian[i][j] = -1.0
+                else:
+                    laplacian[i][j] = 0.0
+
+        # Normalize the Laplacian if requested
+        if normalized:
+            degree_matrix = np.diag(laplacian.diagonal())
+            with np.errstate(divide='ignore'):  # Suppress warnings for division by zero
+                d_inv_sqrt = np.diag(1.0 / np.sqrt(degree_matrix.diagonal()))
+                d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0  # Replace infinities with zero
+
+            normalized_laplacian = d_inv_sqrt @ laplacian @ d_inv_sqrt
+            return normalized_laplacian.tolist()
+
+        return laplacian.tolist()
+
     @staticmethod
     def Leaves(graph, edgeKey: str = None, tolerance: float = 0.0001, silent: bool = False):
         """
@@ -8804,7 +9375,63 @@ class Graph:
             d = Dictionary.SetValueAtKey(d, key, scores[i])
             v = Topology.SetDictionary(v, d)
         return scores
-    
+
+    @staticmethod
+    def Partition(graph, method: str = "Betweenness", n: int = 2, m: int = 10, key: str ="partition",
+                mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Partitions the input graph based on the desired partition method. See https://en.wikipedia.org/wiki/Graph_partition.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        method : str , optional
+            The desired partitioning method. The options are:
+            - "Betweenness"
+            - "Community" or "Louvain"
+            - "Fiedler" or "Eigen"
+            It is case insensitive. The default is "Betweenness"
+        n : int , optional
+            The desired number of partitions when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 2.
+        m : int , optional
+            The desired maximum number of tries to partition the graph when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 10.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the parition number. The default is "partition".
+            Valid partition numbers start from 1. Cut edges receive a partition number of 0.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
+
+        """ 
+        
+        m_d = Graph.MeshData(graph)
+        new_graph = Graph.ByMeshData(vertices = m_d['vertices'],
+                                    edges = m_d['edges'],
+                                    vertexDictionaries = m_d['vertexDictionaries'],
+                                    edgeDictionaries = m_d['edgeDictionaries'])
+        if "between" in method.lower():
+            _ = Graph.BetweennessPartition(new_graph, n=n, m=m, key=key, tolerance=tolerance, silent=silent)
+            return new_graph
+        elif "community" in method.lower() or "louvain" in method.lower():
+            _ = Graph.CommunityPartition(new_graph, key=key, mantissa=mantissa, tolerance=tolerance, silent=silent)
+            return new_graph
+        elif "fied" in method.lower() or "eig" in method.lower():
+            _ = Graph.FiedlerVectorPartition(new_graph, key=key, mantissa=mantissa, tolerance=tolerance, silent=silent)
+            return new_graph
+        else:
+            if not silent:
+                print("Graph.Partition - Error: The chosen method is not supported. Returning None.")
+            return None
+
     @staticmethod
     def Path(graph, vertexA, vertexB, tolerance=0.0001):
         """
@@ -9519,6 +10146,86 @@ class Graph:
             return None
         return len(Graph.Edges(graph))
 
+    @staticmethod
+    def Subgraph(graph, vertices, vertexKey="cutVertex", edgeKey="cutEdge", tolerance=0.0001, silent: bool = False):
+        """
+        Returns a subgraph of the input graph as defined by the input vertices.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexKey : str , optional
+            The dictionary key under which to store the cut vertex status of each vertex. See https://en.wikipedia.org/wiki/Cut_(graph_theory).
+            vertex cuts are indicated with a value of 1. The default is "cutVertex".
+        edgeKey : str , optional
+            The dictionary key under which to store the cut edge status of each edge. See https://en.wikipedia.org/wiki/Cut_(graph_theory).
+            edge cuts are indicated with a value of 1. The default is "cutVertex".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        topologic_core.Graph
+            The created subgraph.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.Subgraph - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Graph.Subgraph - Error: The input vertices parameter is not a valid list. Returning None.")
+            return None
+        
+        vertex_list = [v for v in vertices if Topology.IsInstance(v, "vertex")]
+        if len(vertex_list) < 1:
+            if not silent:
+                print("Graph.Subgraph - Error: The input vertices parameter does not contain any valid vertices. Returning None.")
+            return None
+
+        edges = Graph.Edges(graph, vertices=vertex_list)
+        # Set the vertexCut status to 0 for all input vertices
+        for v in vertex_list:
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, vertexKey, 0)
+            v = Topology.SetDictionary(v, d)
+
+        final_edges = []
+        if not edges == None:
+            for edge in edges:
+                sv = Edge.StartVertex(edge)
+                status_1 = any([Vertex.IsCoincident(sv, v, tolerance=tolerance) for v in vertices])                
+                ev = Edge.EndVertex(edge)
+                status_2 = any([Vertex.IsCoincident(ev, v, tolerance=tolerance) for v in vertices])
+                if status_1 and status_2:
+                    cutEdge = 0
+                else:
+                    cutEdge = 1
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, edgeKey, cutEdge)
+                edge = Topology.SetDictionary(edge, d)
+                final_edges.append(edge)
+        return_graph = Graph.ByVerticesEdges(vertex_list, final_edges)
+        graph_vertices = Graph.Vertices(return_graph)
+        # Any vertex in the final graph that does not have a vertexCut of 0 is a new vertex and as such needs to have a vertexCut of 1.
+        for v in graph_vertices:
+            d = Topology.Dictionary(v)
+            value = Dictionary.ValueAtKey(d, vertexKey)
+            if not value == 0:
+                d = Dictionary.SetValueAtKey(d, vertexKey, 1)
+                v = Topology.SetDictionary(v, d)
+        return return_graph
+
     @staticmethod
     def _topological_distance(g, start, target):
         from collections import deque

topologicpy/Matrix.py

@@ -164,6 +164,69 @@ class Matrix:
                 [0,0,1,0],
                 [translateX,translateY,translateZ,1]]
     
+    @staticmethod
+    def EigenvaluesAndVectors(matrix, mantissa: int = 6, silent: bool = False):
+        import numpy as np
+        """
+        Returns the eigenvalues and eigenvectors of the input matrix. See https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors
+        
+        Parameters
+        ----------
+        matrix : list
+            The input matrix. Assumed to be a laplacian matrix.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        list
+            The list of eigenvalues and eigenvectors of the input matrix.
+
+        """
+        from topologicpy.Helper import Helper
+        import numpy as np
+
+        if not isinstance(matrix, list):
+            if not silent:
+                print("Matrix.Eigenvalues - Error: The input matrix parameter is not a valid matrix. Returning None.")
+            return None
+        
+        np_matrix = np.array(matrix)
+        if not isinstance(np_matrix, np.ndarray):
+            if not silent:
+                print("Matrix.Eigenvalues - Error: The input matrix parameter is not a valid matrix. Returning None.")
+            return None
+        
+        # Square check
+        if np_matrix.shape[0] != np_matrix.shape[1]:
+            if not silent:
+                print("Matrix.Eigenvalues - Error: The input matrix parameter is not a square matrix. Returning None.")
+            return None
+        
+        # Symmetry check
+        if not np.allclose(np_matrix, np_matrix.T):
+            if not silent:
+                print("Matrix.Eigenvalues - Error: The input matrix is not symmetric. Returning None.")
+            return None
+        
+        # # Degree matrix
+        # degree_matrix = np.diag(np_matrix.sum(axis=1))
+        
+        # # Laplacian matrix
+        # laplacian_matrix = degree_matrix - np_matrix
+        
+        # Eigenvalues
+        eigenvalues, eigenvectors = np.linalg.eig(np_matrix)
+        
+        e_values = [round(x, mantissa) for x in list(np.sort(eigenvalues))]
+        e_vectors = []
+        for eigenvector in eigenvectors:
+            e_vectors.append([round(x, mantissa) for x in eigenvector])
+        e_vectors = Helper.Sort(e_vectors, list(eigenvalues))
+        return e_values, e_vectors
+    
     @staticmethod
     def Multiply(matA, matB):
         """

topologicpy/Vertex.py

@@ -1710,6 +1710,89 @@ class Vertex():
         pt = project_point_onto_plane(Vertex.Coordinates(vertex), [eq["a"], eq["b"], eq["c"], eq["d"]], direction)
         return Vertex.ByCoordinates(pt[0], pt[1], pt[2])
 
+    @staticmethod
+    def Separate(*vertices, minDistance: float = 0.0001, silent: bool = False):
+        """
+        Separates the input vertices such that no two vertices are within the input minimum distance.
+
+        Parameters
+        ----------
+        vertices : *topologicpy.Vertex
+            One or more instances of a topologic vertex to be processed.
+        minDistance : float , optional
+            The desired minimum distance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        list
+            The list of vertices with adjusted positions
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+        from topologicpy.Dictionary import Dictionary
+        from math import sqrt
+        from scipy.spatial import KDTree
+        import numpy as np
+
+        if len(vertices) == 0:
+            if not silent:
+                print("Vertex.Separate - Error: The input vertices parameter is an empty list. Returning None.")
+            return None
+        if len(vertices) == 1:
+            vertices = vertices[0]
+            if isinstance(vertices, list):
+                if len(vertices) == 0:
+                    if not silent:
+                        print("Vertex.Separate - Error: The input vertices parameter is an empty list. Returning None.")
+                    return None
+                else:
+                    vertexList = [x for x in vertices if Topology.IsInstance(x, "Vertex")]
+                    if len(vertexList) == 0:
+                        if not silent:
+                            print("Vertex.Separate - Error: The input vertices parameter does not contain any valid vertices. Returning None.")
+                        return None
+            else:
+                if not silent:
+                    print("Vertex.Separate - Warning: The input vertices parameter contains only one vertex. Returning the same vertex.")
+                return vertices
+        else:
+            vertexList = Helper.Flatten(list(vertices))
+            vertexList = [x for x in vertexList if Topology.IsInstance(x, "Vertex")]
+        if len(vertexList) == 0:
+            if not silent:
+                print("Vertex.Separate - Error: The input parameters do not contain any valid vertices. Returning None.")
+            return None
+    
+        coords = np.array([[v.X(), v.Y(), v.Z()] for v in vertexList])  # Extract coordinates
+        tree = KDTree(coords)  # Build k-d tree for efficient neighbor search
+        
+        for i, vertex in enumerate(coords):
+            neighbors = tree.query_ball_point(vertex, minDistance)
+            for neighbor_index in neighbors:
+                if neighbor_index != i:  # Avoid self-comparison
+                    direction = coords[neighbor_index] - vertex
+                    distance = np.linalg.norm(direction)
+                    if distance < minDistance:
+                        # Move current vertex away from its neighbor
+                        adjustment = (minDistance - distance) / 2
+                        unit_vector = direction / distance if distance != 0 else np.random.rand(3)
+                        coords[i] -= unit_vector * adjustment
+                        coords[neighbor_index] += unit_vector * adjustment
+
+            # Rebuild the k-d tree after adjustment
+            tree = KDTree(coords)
+
+        # Convert adjusted coordinates back to Vertex objects
+        separated_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
+        for i, vertex in enumerate(vertexList):
+            d = Topology.Dictionary(vertex)
+            if len(Dictionary.Keys(d)) > 0:
+                separated_vertices[i] = Topology.SetDictionary(separated_vertices[i], d)
+        return separated_vertices
+
     @staticmethod
     def X(vertex, mantissa: int = 6) -> float:
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.97'
+__version__ = '0.7.99'

{topologicpy-0.7.97.dist-info → topologicpy-0.7.99.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.97
+Version: 0.7.99
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.7.97.dist-info → topologicpy-0.7.99.dist-info}/RECORD

@@ -11,11 +11,11 @@ topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,331
 topologicpy/Edge.py,sha256=gaLqyjFOqFHpw69Ftr4rc-kvakYpauQwhOK4ZO-V35g,67287
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=wczXpMcfub8Eb10lA4rrXksvi5YYCbRjBdp3lOTUwK0,172618
-topologicpy/Graph.py,sha256=tAm-kvvHAgadPJIcXvqgEoMuAdAo3RS3mu9uhhgx7TI,460497
+topologicpy/Graph.py,sha256=-vB47i0s7fbh6pTQGuiJujm1tM-ubTuUeyjJeQ8iAEo,492172
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=F3h4_qcOD_PHAoVe0tEbEE7_jYyVcaHjtwVs4QHOZuI,23978
 topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
-topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
+topologicpy/Matrix.py,sha256=tiPum1gTvkKxOyxHBDviH4BwLbdlAusBwMe7ZZfu6Po,10510
 topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
 topologicpy/Plotly.py,sha256=Tvo0_zKVEHtPhsMNNvLy5G0HIys5FPAOyp_o4QN_I_A,115760
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
@@ -25,12 +25,12 @@ topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
 topologicpy/Topology.py,sha256=kAnJrVyrwJX8c-C4q1cewJ80byG8uaoBWUuk0T6U4SY,441788
 topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
-topologicpy/Vertex.py,sha256=QkeNPFTX-adKhEHMole0et9FCy0xXmTHVcmsYqqotSw,73904
+topologicpy/Vertex.py,sha256=tv6C-rbuNgXHDGgVLT5fbalynLdXqlUuiCDKtkeQ0vk,77814
 topologicpy/Wire.py,sha256=bX8wO96gFa7HZPY0CFlmYQBOUP_1e0jCb02BPxaY-ao,222981
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=eF2oD9YC4qAbKpy4BgX03mi3PRuOcHb_V4K8lN5jAn0,23
-topologicpy-0.7.97.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.97.dist-info/METADATA,sha256=pingqvbKxBUf-eX6CrZQCoIyEV1tduXqvZwpol4DDuQ,10513
-topologicpy-0.7.97.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.97.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.97.dist-info/RECORD,,
+topologicpy/version.py,sha256=gGhfskMFYv1QhkPM9mcpO5BWm5CMyWE6f2zQSx3Zec4,23
+topologicpy-0.7.99.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.99.dist-info/METADATA,sha256=Mzw982237903EfiTROFP2zAKuxkY8RIBQ1GjJdJQ-9s,10513
+topologicpy-0.7.99.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.99.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.99.dist-info/RECORD,,