topologicpy 0.7.96__py3-none-any.whl → 0.7.98__py3-none-any.whl

topologicpy/Graph.py

@@ -750,102 +750,6 @@ class Graph:
         _ = graph.AllPaths(vertexA, vertexB, True, timeLimit, paths) # Hook to Core
         return paths
 
-    @staticmethod
-    def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
-        """
-        Tests if the two input graphs are isomorphic according to the Weisfeiler Lehman graph isomorphism test. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
-        
-        Parameters
-        ----------
-        graphA : topologic_core.Graph
-            The first input graph.
-        graphB : topologic_core.Graph
-            The second input graph.
-        maxIterations : int , optional
-            This number limits the number of iterations to prevent the function from running indefinitely, particularly for very large or complex graphs.
-        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 two input graphs are isomorphic. False otherwise
-
-        """
-
-        from topologicpy.Topology import Topology
-
-        def weisfeiler_lehman_test(graph1, graph2, max_iterations=10):
-            """
-            Test if two graphs are isomorphic using the Weisfeiler-Leman (WL) algorithm with early stopping.
-
-            Parameters:
-            graph1 (dict): Adjacency list representation of the first graph.
-            graph2 (dict): Adjacency list representation of the second graph.
-            max_iterations (int): Maximum WL iterations allowed (default is 10).
-
-            Returns:
-            bool: True if the graphs are WL-isomorphic, False otherwise.
-            """
-
-            def wl_iteration(labels, graph):
-                """Perform one WL iteration and return updated labels."""
-                new_labels = {}
-                for node in graph:
-                    neighborhood_labels = sorted([labels[neighbor] for neighbor in graph[node]])
-                    new_labels[node] = (labels[node], tuple(neighborhood_labels))
-                unique_labels = {}
-                count = 0
-                for node in sorted(new_labels):
-                    if new_labels[node] not in unique_labels:
-                        unique_labels[new_labels[node]] = count
-                        count += 1
-                    new_labels[node] = unique_labels[new_labels[node]]
-                return new_labels
-
-            # Initialize labels
-            labels1 = {node: 1 for node in graph1}
-            labels2 = {node: 1 for node in graph2}
-
-            for i in range(max_iterations):
-                # Perform WL iteration for both graphs
-                new_labels1 = wl_iteration(labels1, graph1)
-                new_labels2 = wl_iteration(labels2, graph2)
-
-                # Check if the label distributions match
-                if sorted(new_labels1.values()) != sorted(new_labels2.values()):
-                    return False
-
-                # Check for stability (early stopping)
-                if new_labels1 == labels1 and new_labels2 == labels2:
-                    break
-
-                # Update labels for next iteration
-                labels1, labels2 = new_labels1, new_labels2
-
-            return True
-        
-        if not Topology.IsInstance(graphA, "Graph") and not Topology.IsInstance(graphB, "Graph"):
-            if not silent:
-                print("Graph.IsIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
-            return None
-        if not Topology.IsInstance(graphA, "Graph"):
-            if not silent:
-                print("Graph.IsIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
-            return None
-        if not Topology.IsInstance(graphB, "Graph"):
-            if not silent:
-                print("Graph.IsIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
-            return None
-        if maxIterations <= 0:
-            if not silent:
-                print("Graph.IsIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
-            return None
-        
-        g1 = Graph.AdjacencyDictionary(graphA)
-        g2 = Graph.AdjacencyDictionary(graphB)
-        return weisfeiler_lehman_test(g1, g2, max_iterations=maxIterations)
-
     @staticmethod
     def AverageClusteringCoefficient(graph, mantissa: int = 6, silent: bool = False):
         """
@@ -1336,16 +1240,18 @@ 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
         ----------
         graph : topologic_core.Graph
             The input graph.
         key : str , optional
-            The dictionary key under which to save the betweeness centrality score. The default is "betweenness_centrality".
+            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
@@ -1372,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)
@@ -1387,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
 
@@ -1395,39 +1351,176 @@ 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 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
+
+    @staticmethod
+    def Bridges(graph, key: str = "bridge", silent: bool = False):
+        """
+        Returns the list of bridge edges in the input graph. See: https://en.wikipedia.org/wiki/Bridge_(graph_theory)
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        key : str , optional
+            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.
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
+
+        if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.BetweenessCentrality - Error: The input graph does not contain valid vertices. Returning None.")
+                print("Graph.Bridges - Error: The input graph parameter is not a valid topologic graph. 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
 
-        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
-    
+        graph_edges = Graph.Edges(graph)
+        for edge in graph_edges:
+            d = Topology.Dictionary(edge)
+            d = Dictionary.SetValueAtKey(d, key, 0)
+            edge = Topology.SetDictionary(edge, d)
+        mesh_data = Graph.MeshData(graph)
+        mesh_edges = mesh_data['edges']
+
+        # 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 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)
+            d = Dictionary.SetValueAtKey(d, key, 1)
+            edge = Topology.SetDictionary(edge, d)
+
+        return bridge_edges
+
     @staticmethod
     def ByAdjacencyMatrixCSVPath(path: str, dictionaries: list = None, silent: bool = False):
         """
@@ -1514,7 +1607,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
@@ -4181,6 +4275,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):
         """
@@ -4410,7 +4580,7 @@ class Graph:
         vertices : list , optional
             The input list of vertices. The default is None.
         key : str , optional
-            The dictionary key under which to save the closeness centrality score. The default is "closeness_centrality".
+            The dictionary key under which to store the closeness centrality score. The default is "closeness_centrality".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -4498,7 +4668,7 @@ class Graph:
         graph : topologicp.Graph
             The input topologic graph.
         key : str , optional
-            The dictionary key under which to save the closeness centrality score. The default is "community".
+            The dictionary key under which to store the closeness centrality score. The default is "community".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -4610,7 +4780,7 @@ class Graph:
         vertices : list , optional
             The input list of vertices. The default is None.
         key : str , optional
-            The dictionary key under which to save the connectivity score. The default is "connectivity".
+            The dictionary key under which to store the connectivity score. The default is "connectivity".
         edgeKey : str , optional
             If specified, the value in the connected edges' dictionary specified by the edgeKey string will be aggregated to calculate
             the vertex degree. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead. This is used in weighted graphs.
@@ -4705,6 +4875,67 @@ class Graph:
             return None
         return graph.ContainsVertex(vertex, tolerance) # Hook to Core
 
+    @staticmethod
+    def CutVertices(graph, key: str = "cut", silent: bool = False):
+        """
+        Returns the list of cut vertices in the input graph. See: https://en.wikipedia.org/wiki/Bridge_(graph_theory)
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        key : str , optional
+            The vertex dictionary key under which to store the cut status. 0 means the vertex is NOT a cut vertex. 1 means that the vertex IS a cut vertex. The default is "cut".
+        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
+
+        try:
+            import igraph as ig
+        except:
+            print("Graph.CutVertices - 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.CutVertices - python-igraph library installed correctly.")
+            except:
+                warnings.warn("Graph.CutVertices - Error: Could not import python-igraph. Please install manually.")
+        
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.CutVertices - Error: The input graph parameter is not a valid topologic graph. Returning None")
+            return None
+        
+        vertices = Graph.Vertices(graph)
+        mesh_data = Graph.MeshData(graph)
+        graph_edges = mesh_data['edges']
+        ig_graph = ig.Graph(edges=graph_edges)
+        articulation_points = ig_graph.vs[ig_graph.articulation_points()]
+        articulation_points_list = [v.index for v in articulation_points]
+        cut_vertices = []
+        for i, vertex in enumerate(vertices):
+            d = Topology.Dictionary(vertex)
+            if i in articulation_points_list:
+                d = Dictionary.SetValueAtKey(d, key, 1)
+                cut_vertices.append(vertex)
+            else:
+                d = Dictionary.SetValueAtKey(d, key, 0)
+            vertex = Topology.SetDictionary(vertex, d)
+                
+        return cut_vertices
 
     @staticmethod
     def Degree(graph, vertices=None, key: str = "degree", edgeKey: str = None, mantissa: int = 6, tolerance = 0.0001):
@@ -4718,7 +4949,7 @@ class Graph:
         vertices : list , optional
             The input list of vertices. The default is None.
         key : str , optional
-            The dictionary key under which to save the closeness centrality score. The default is "degree".
+            The dictionary key under which to store the closeness centrality score. The default is "degree".
         edgeKey : str , optional
             If specified, the value in the connected edges' dictionary specified by the edgeKey string will be aggregated to calculate
             the vertex degree. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead. This is used in weighted graphs.
@@ -4760,6 +4991,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):
         """
@@ -4874,7 +5127,7 @@ class Graph:
         vertices : list , optional
             The input list of vertices. The default is None.
         key : str , optional
-            The dictionary key under which to save the depth score. The default is "depth".
+            The dictionary key under which to store the depth score. The default is "depth".
         type : str , optional
             The type of depth distance to calculate. The options are "topological" or "metric". The default is "topological". See https://www.spacesyntax.online/overview-2/analysis-of-spatial-relations/.
         mantissa : int , optional
@@ -6127,7 +6380,134 @@ class Graph:
                 f.close()
                 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 IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
+        """
+        Tests if the two input graphs are isomorphic according to the Weisfeiler Lehman graph isomorphism test. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
+        
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        maxIterations : int , optional
+            This number limits the number of iterations to prevent the function from running indefinitely, particularly for very large or complex graphs.
+        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 two input graphs are isomorphic. False otherwise
+
+        """
+
+        from topologicpy.Topology import Topology
+
+        def weisfeiler_lehman_test(graph1, graph2, max_iterations=10):
+            """
+            Test if two graphs are isomorphic using the Weisfeiler-Leman (WL) algorithm with early stopping.
+
+            Parameters:
+            graph1 (dict): Adjacency list representation of the first graph.
+            graph2 (dict): Adjacency list representation of the second graph.
+            max_iterations (int): Maximum WL iterations allowed (default is 10).
+
+            Returns:
+            bool: True if the graphs are WL-isomorphic, False otherwise.
+            """
+
+            def wl_iteration(labels, graph):
+                """Perform one WL iteration and return updated labels."""
+                new_labels = {}
+                for node in graph:
+                    neighborhood_labels = sorted([labels[neighbor] for neighbor in graph[node]])
+                    new_labels[node] = (labels[node], tuple(neighborhood_labels))
+                unique_labels = {}
+                count = 0
+                for node in sorted(new_labels):
+                    if new_labels[node] not in unique_labels:
+                        unique_labels[new_labels[node]] = count
+                        count += 1
+                    new_labels[node] = unique_labels[new_labels[node]]
+                return new_labels
+
+            # Initialize labels
+            labels1 = {node: 1 for node in graph1}
+            labels2 = {node: 1 for node in graph2}
+
+            for i in range(max_iterations):
+                # Perform WL iteration for both graphs
+                new_labels1 = wl_iteration(labels1, graph1)
+                new_labels2 = wl_iteration(labels2, graph2)
+
+                # Check if the label distributions match
+                if sorted(new_labels1.values()) != sorted(new_labels2.values()):
+                    return False
+
+                # Check for stability (early stopping)
+                if new_labels1 == labels1 and new_labels2 == labels2:
+                    break
+
+                # Update labels for next iteration
+                labels1, labels2 = new_labels1, new_labels2
+
+            return True
+        
+        if not Topology.IsInstance(graphA, "Graph") and not Topology.IsInstance(graphB, "Graph"):
+            if not silent:
+                print("Graph.IsIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
+            return None
+        if not Topology.IsInstance(graphA, "Graph"):
+            if not silent:
+                print("Graph.IsIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "Graph"):
+            if not silent:
+                print("Graph.IsIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
+            return None
+        if maxIterations <= 0:
+            if not silent:
+                print("Graph.IsIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
+            return None
+        
+        g1 = Graph.AdjacencyDictionary(graphA)
+        g2 = Graph.AdjacencyDictionary(graphB)
+        return weisfeiler_lehman_test(g1, g2, max_iterations=maxIterations)
+
     @staticmethod
     def Reshape(graph,
                 shape="spring 2D",
@@ -7382,6 +7762,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):
         """
@@ -7648,6 +8081,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):
         """
@@ -7767,7 +8255,7 @@ class Graph:
         vertices : list , optional
             The input list of vertices. If set to None, the local clustering coefficient of all vertices will be computed. The default is None.
         key : str , optional
-            The dictionary key under which to save the local clustering coefficient score. The default is "lcc".
+            The dictionary key under which to store the local clustering coefficient score. The default is "lcc".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -8424,11 +8912,11 @@ class Graph:
         graph : topologic_core.Graph
             The input graph.
         xKey : str , optional
-            The dictionary key under which to save the X-Coordinate of the vertex. The default is 'x'.
+            The dictionary key under which to store the X-Coordinate of the vertex. The default is 'x'.
         yKey : str , optional
-            The dictionary key under which to save the Y-Coordinate of the vertex. The default is 'y'.
+            The dictionary key under which to store the Y-Coordinate of the vertex. The default is 'y'.
         zKey : str , optional
-            The dictionary key under which to save the Z-Coordinate of the vertex. The default is 'z'.
+            The dictionary key under which to store the Z-Coordinate of the vertex. The default is 'z'.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -8627,7 +9115,7 @@ class Graph:
         directed : bool , optional
             If set to True, the graph is considered as a directed graph. Otherwise, it will be considered as an undirected graph. The default is False.
         key : str , optional
-            The dictionary key under which to save the page_rank score. The default is "page_rank"
+            The dictionary key under which to store the page_rank score. The default is "page_rank"
         mantissa : int , optional
             The desired length of the mantissa.
         tolerance : float , optional
@@ -9390,6 +9878,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.96'
+__version__ = '0.7.98'

{topologicpy-0.7.96.dist-info → topologicpy-0.7.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.96
+Version: 0.7.98
 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.96.dist-info → topologicpy-0.7.98.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=Zx4dzSTynaJP1dEZ1j5WuneaTv2N2fbeNTyMwaI947c,455395
+topologicpy/Graph.py,sha256=IL7htimFIpRIFSGlNgXqdIkq6KgHFUe9T144yGIk2Qc,479404
 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=a9u4mrbOh52xm2kgTG2gE8Y-NjoOtc82edCsxZY1Zs0,23
-topologicpy-0.7.96.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.96.dist-info/METADATA,sha256=nVJinnZ504srDkDfjHbmyKZWpWEy6TchQp9nfijkKUY,10513
-topologicpy-0.7.96.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.96.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.96.dist-info/RECORD,,
+topologicpy/version.py,sha256=edt03iPp-fWm-GyKIDUNJimGnmtCRb6Pjv3dsEvhru4,23
+topologicpy-0.7.98.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.98.dist-info/METADATA,sha256=U6xzVbESx3zzAX4CakRjfE90LNZLqEdPZMN3SKbRBdQ,10513
+topologicpy-0.7.98.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.98.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.98.dist-info/RECORD,,