graph-matrix-analysis 0.1.0__tar.gz

graph_matrix_analysis-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aitor Merino, Xabier Labraga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

graph_matrix_analysis-0.1.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: graph_matrix_analysis
+Version: 0.1.0
+Summary: Library for analyzing graphs based on their adjacency matrix
+Author-email: Aitor Merino <aitor.merino@alumni.mondragon.edu>, Xabier Labraga <xabier.labraga@alumni.mondragon.edu>
+License-Expression: MIT
+Keywords: graphs,adjacency matrix,euler,dijkstra,bellman-ford,isomorphism
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: networkx
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# graph_matrix_analysis
+
+Python library to analyze graphs from their **adjacency matrix**.
+
+With a matrix you can:
+
+- check whether the graph is **simple, complete, a multigraph, a pseudograph or directed**,
+- check whether it is **Eulerian** or **semi-Eulerian**,
+- check whether it is **connected** (using the connectivity matrix `C = A + A² + … + Aⁿ⁻¹`),
+- compute the **shortest path** between two vertices with **Bellman-Ford** and draw the graph,
+- check whether two matrices represent **isomorphic** graphs.
+
+## Installation
+
+```bash
+pip install graph_matrix_analysis
+```
+
+It also installs `networkx` and `matplotlib`, which are used to draw the graph.
+
+## The matrix
+
+The matrix is a square list of lists. `A[i][j]` is the number of edges from vertex `i` to vertex `j`, and vertices are numbered starting at 0. If the matrix is not square, `InvalidMatrixError` is raised.
+
+## Usage
+
+```python
+from graph_matrix_analysis import Properties, Connectivity, WeightedGraph, Isomorphism
+
+A = [
+    [0, 1, 1, 0],
+    [1, 0, 1, 1],
+    [1, 1, 0, 1],
+    [0, 1, 1, 0],
+]
+```
+
+### Properties (`Properties`)
+
+```python
+p = Properties(A)
+
+p.count_vertex()   # 4
+p.count_edges()    # 5
+p.simple()         # True
+p.complete()       # False
+p.pseudograph()    # False
+p.multigraph()     # False
+p.digraph()        # False
+p.eulerian()       # False
+p.semieulerian()   # True
+```
+
+| Method | Returns `True` if... |
+|---|---|
+| `simple()` | it has no loops or multiple edges |
+| `complete()` | there is an edge between every pair of vertices |
+| `pseudograph()` | it has at least one loop |
+| `multigraph()` | it has multiple edges between distinct vertices |
+| `digraph()` | the matrix is not symmetric (directed graph) |
+| `eulerian()` | all vertices have even degree |
+| `semieulerian()` | exactly two vertices have odd degree |
+
+### Connectivity (`Connectivity`)
+
+```python
+c = Connectivity(A)
+
+c.connected()            # True
+c.connectivity_matrix()  # [[4, 7, 7, 4], [7, 7, 8, 7], [7, 8, 7, 7], [4, 7, 7, 4]]
+```
+
+`connectivity_matrix()` computes `C = A + A² + … + Aⁿ⁻¹`. The graph is connected if all off-diagonal entries of `C` are non-zero.
+
+### Shortest path (`WeightedGraph`)
+
+```python
+W = [
+    [0, 4, 5, 0],
+    [0, 0, -3, 6],
+    [0, 0, 0, 2],
+    [0, 0, 0, 0],
+]
+g = WeightedGraph(W)
+
+g.bellman_ford(0, 3)   # ([0, 1, 2, 3], 3)  -> (path, distance)
+g.bellman_ford(3, 0)   # 'No path exists'
+g.plot_graph()         # draws the graph with its weights
+```
+
+Here the matrix is a **weight** matrix: `W[i][j]` is the weight of the edge from `i` to `j`, and 0 means there is no edge. Negative weights are allowed; if there is a negative cycle, it returns `'Negative cycle detected'`.
+
+### Isomorphism (`Isomorphism`)
+
+```python
+B = [
+    [0, 1, 1, 1],
+    [1, 0, 1, 0],
+    [1, 1, 0, 1],
+    [1, 0, 1, 0],
+]
+
+Isomorphism(A, B).isomorphic()   # True
+```
+
+It tries every permutation of the vertices, so it is only practical for small graphs.
+
+## Development
+
+```bash
+git clone https://github.com/tuusuario/graph_matrix_analysis
+cd grafomatriz
+pip install -e .
+pip install pytest
+pytest
+```
+
+## License
+
+MIT

graph_matrix_analysis-0.1.0/README.md

@@ -0,0 +1,120 @@
+# graph_matrix_analysis
+
+Python library to analyze graphs from their **adjacency matrix**.
+
+With a matrix you can:
+
+- check whether the graph is **simple, complete, a multigraph, a pseudograph or directed**,
+- check whether it is **Eulerian** or **semi-Eulerian**,
+- check whether it is **connected** (using the connectivity matrix `C = A + A² + … + Aⁿ⁻¹`),
+- compute the **shortest path** between two vertices with **Bellman-Ford** and draw the graph,
+- check whether two matrices represent **isomorphic** graphs.
+
+## Installation
+
+```bash
+pip install graph_matrix_analysis
+```
+
+It also installs `networkx` and `matplotlib`, which are used to draw the graph.
+
+## The matrix
+
+The matrix is a square list of lists. `A[i][j]` is the number of edges from vertex `i` to vertex `j`, and vertices are numbered starting at 0. If the matrix is not square, `InvalidMatrixError` is raised.
+
+## Usage
+
+```python
+from graph_matrix_analysis import Properties, Connectivity, WeightedGraph, Isomorphism
+
+A = [
+    [0, 1, 1, 0],
+    [1, 0, 1, 1],
+    [1, 1, 0, 1],
+    [0, 1, 1, 0],
+]
+```
+
+### Properties (`Properties`)
+
+```python
+p = Properties(A)
+
+p.count_vertex()   # 4
+p.count_edges()    # 5
+p.simple()         # True
+p.complete()       # False
+p.pseudograph()    # False
+p.multigraph()     # False
+p.digraph()        # False
+p.eulerian()       # False
+p.semieulerian()   # True
+```
+
+| Method | Returns `True` if... |
+|---|---|
+| `simple()` | it has no loops or multiple edges |
+| `complete()` | there is an edge between every pair of vertices |
+| `pseudograph()` | it has at least one loop |
+| `multigraph()` | it has multiple edges between distinct vertices |
+| `digraph()` | the matrix is not symmetric (directed graph) |
+| `eulerian()` | all vertices have even degree |
+| `semieulerian()` | exactly two vertices have odd degree |
+
+### Connectivity (`Connectivity`)
+
+```python
+c = Connectivity(A)
+
+c.connected()            # True
+c.connectivity_matrix()  # [[4, 7, 7, 4], [7, 7, 8, 7], [7, 8, 7, 7], [4, 7, 7, 4]]
+```
+
+`connectivity_matrix()` computes `C = A + A² + … + Aⁿ⁻¹`. The graph is connected if all off-diagonal entries of `C` are non-zero.
+
+### Shortest path (`WeightedGraph`)
+
+```python
+W = [
+    [0, 4, 5, 0],
+    [0, 0, -3, 6],
+    [0, 0, 0, 2],
+    [0, 0, 0, 0],
+]
+g = WeightedGraph(W)
+
+g.bellman_ford(0, 3)   # ([0, 1, 2, 3], 3)  -> (path, distance)
+g.bellman_ford(3, 0)   # 'No path exists'
+g.plot_graph()         # draws the graph with its weights
+```
+
+Here the matrix is a **weight** matrix: `W[i][j]` is the weight of the edge from `i` to `j`, and 0 means there is no edge. Negative weights are allowed; if there is a negative cycle, it returns `'Negative cycle detected'`.
+
+### Isomorphism (`Isomorphism`)
+
+```python
+B = [
+    [0, 1, 1, 1],
+    [1, 0, 1, 0],
+    [1, 1, 0, 1],
+    [1, 0, 1, 0],
+]
+
+Isomorphism(A, B).isomorphic()   # True
+```
+
+It tries every permutation of the vertices, so it is only practical for small graphs.
+
+## Development
+
+```bash
+git clone https://github.com/tuusuario/graph_matrix_analysis
+cd grafomatriz
+pip install -e .
+pip install pytest
+pytest
+```
+
+## License
+
+MIT

graph_matrix_analysis-0.1.0/graph_matrix_analysis/__init__.py

@@ -0,0 +1,7 @@
+from .core import InvalidMatrixError
+from .core import Properties
+from .core import Connectivity
+from .core import WeightedGraph
+from .core import Isomorphism
+
+__version__ = "0.1.0"

graph_matrix_analysis-0.1.0/graph_matrix_analysis/core.py

@@ -0,0 +1,233 @@
+import networkx as nx
+import matplotlib as plt
+
+class InvalidMatrixError(Exception):
+    pass
+
+def check_matrix(A):
+    n = len(A)
+    for i in range(n):
+        if len(A[i]) != n:
+            raise InvalidMatrixError('The matrix is not square')
+
+class Properties:
+    def __init__(self, A):
+        check_matrix(A)
+        self.A = A
+        self.n = len(A)
+
+    def count_vertex(self): # Number of vertices
+        return self.n
+
+    def count_edges(self): # Number of edges
+        edges = 0
+        for i in range(self.n):
+            for j in range(self.n):
+                edges += self.A[i][j]
+        return edges // 2
+
+    def simple(self): # Simple graph
+        for i in range(self.n):
+            if self.A[i][i] != 0:
+                return False 
+
+            for j in range(self.n):
+                if self.A[i][j] > 1:
+                    return False
+        return True
+
+    def complete(self): # Complete graph
+        for i in range(self.n):
+            for j in range(self.n):
+                if i != j and self.A[i][j] == 0:
+                    return False
+        return True
+
+    def pseudograph(self): # Pseudograph
+        for i in range(self.n):
+            if self.A[i][i] > 0:
+                return True
+        return False
+
+    def multigraph(self): # Multigraph
+        for i in range(self.n):
+            for j in range(self.n):
+                if i != j and self.A[i][j] > 1:
+                    return True
+        return False
+
+    def digraph(self): # Directed graph
+        for i in range(self.n):
+            for j in range(self.n):
+                if self.A[i][j] != self.A[j][i]:
+                    return True
+        return False
+
+    def eulerian(self): # Eulerian graph
+        for i in range(self.n):
+            degree = sum(self.A[i])
+            if degree % 2 != 0:
+                return False
+        return True
+
+    def semieulerian(self): # Semi-Eulerian graph
+        odd = 0
+        for i in range(self.n):
+            degree = sum(self.A[i])
+            if degree % 2 != 0:
+                odd += 1
+        return odd == 2
+
+class Connectivity:
+    def __init__(self, A):
+        check_matrix(A)
+        self.A = A
+        self.n = len(A)
+
+    def multiply(self, A, B):
+        C = []
+        for i in range(self.n):
+            row = []
+            for j in range(self.n):
+                row.append(0)
+            C.append(row)
+                
+        for i in range(self.n):
+            for j in range(self.n):
+                for k in range(self.n):
+                    C[i][j] += A[i][k] * B[k][j]
+        return C
+
+    def connectivity_matrix(self):
+        C = []
+        for i in range(self.n):
+            row = []
+            for j in range(self.n):
+                row.append(0)
+            C.append(row)
+        
+        P = self.A
+        for k in range(1, self.n):
+            for i in range(self.n):
+                for j in range(self.n):
+                    C[i][j] += P[i][j]
+            P = self.multiply(P, self.A)
+        return C
+
+    def connected(self):
+        C = self.connectivity_matrix()
+        for i in range(self.n):
+            for j in range(self.n):
+                if i != j and C[i][j] == 0:
+                    return False
+        return True
+
+class WeightedGraph:
+    def __init__(self, W):
+        check_matrix(W)
+        self.W = W
+        self.n = len(W)
+
+    def bellman_ford(self, start, end):
+        distance = []
+        for i in range(self.n): # Initialize distances
+            distance.append(float('inf'))
+        distance[start] = 0
+
+        predecessor = []
+        for i in range(self.n): # Initialize predecessors
+            predecessor.append(None)
+
+        # Bellman-Ford algorithm
+        for k in range(self.n - 1):
+            for i in range(self.n):
+                for j in range(self.n):
+                    if self.W[i][j] != 0:
+                        if distance[i] != float('inf'):
+                            if distance[i] + self.W[i][j] < distance[j]:
+                                distance[j] = distance[i] + self.W[i][j]
+                                predecessor[j] = i
+
+        # Check negative cycles
+        for i in range(self.n):
+            for j in range(self.n):
+                if self.W[i][j] != 0:
+                    if distance[i] != float('inf'):
+                        if distance[i] + self.W[i][j] < distance[j]:
+                            return "Negative cycle detected"
+
+        if distance[end] == float('inf'): # Check if destination is reachable
+            return "No path exists"
+
+        # Reconstruct shortest path
+        path = []
+        current = end
+
+        while current != None:
+            path.append(current)
+            current = predecessor[current]
+        path.reverse()
+
+        return path, distance[end]
+
+def plot_graph(self):
+        G = nx.DiGraph()
+        for i in range(self.n): # Add vertices
+            G.add_node(i)
+
+        # Add edges and weights
+        for i in range(self.n):
+            for j in range(self.n):
+                if self.W[i][j] != 0:
+                    G.add_edge(i, j, weight=self.W[i][j])
+
+        # Draw graph
+        pos = nx.spring_layout(G)
+        nx.draw(G, pos, with_labels = True, node_color = 'lightblue', node_size = 800, font_size = 12, arrows = True)
+
+        # Draw edge weights
+        labels = nx.get_edge_attributes(G, 'weight')
+
+        nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
+
+        plt.title("Weighted Graph")
+        plt.show()
+
+class Isomorphism:
+    def __init__(self, A, B):
+        check_matrix(A)
+        check_matrix(B)
+        self.A = A
+        self.B = B
+        self.n = len(A)
+
+    def check(self, p):
+        for i in range(self.n):
+            for j in range(self.n):
+                if self.A[i][j] != self.B[p[i]][p[j]]:
+                    return False
+        return True
+
+    def generate(self, p, used):
+        if len(p) == self.n:
+            return self.check(p)
+
+        for i in range(self.n):
+            if not used[i]:
+                p.append(i)
+                used[i] = True
+                if self.generate(p, used):
+                    return True
+                p.pop()
+                used[i] = False
+        return False
+
+    def isomorphic(self):
+        if len(self.A) != len(self.B):
+            return False
+        p = []
+        used = []
+
+        for i in range(self.n):
+            used.append(False)
+        return self.generate(p, used)

graph_matrix_analysis-0.1.0/graph_matrix_analysis.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: graph_matrix_analysis
+Version: 0.1.0
+Summary: Library for analyzing graphs based on their adjacency matrix
+Author-email: Aitor Merino <aitor.merino@alumni.mondragon.edu>, Xabier Labraga <xabier.labraga@alumni.mondragon.edu>
+License-Expression: MIT
+Keywords: graphs,adjacency matrix,euler,dijkstra,bellman-ford,isomorphism
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: networkx
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# graph_matrix_analysis
+
+Python library to analyze graphs from their **adjacency matrix**.
+
+With a matrix you can:
+
+- check whether the graph is **simple, complete, a multigraph, a pseudograph or directed**,
+- check whether it is **Eulerian** or **semi-Eulerian**,
+- check whether it is **connected** (using the connectivity matrix `C = A + A² + … + Aⁿ⁻¹`),
+- compute the **shortest path** between two vertices with **Bellman-Ford** and draw the graph,
+- check whether two matrices represent **isomorphic** graphs.
+
+## Installation
+
+```bash
+pip install graph_matrix_analysis
+```
+
+It also installs `networkx` and `matplotlib`, which are used to draw the graph.
+
+## The matrix
+
+The matrix is a square list of lists. `A[i][j]` is the number of edges from vertex `i` to vertex `j`, and vertices are numbered starting at 0. If the matrix is not square, `InvalidMatrixError` is raised.
+
+## Usage
+
+```python
+from graph_matrix_analysis import Properties, Connectivity, WeightedGraph, Isomorphism
+
+A = [
+    [0, 1, 1, 0],
+    [1, 0, 1, 1],
+    [1, 1, 0, 1],
+    [0, 1, 1, 0],
+]
+```
+
+### Properties (`Properties`)
+
+```python
+p = Properties(A)
+
+p.count_vertex()   # 4
+p.count_edges()    # 5
+p.simple()         # True
+p.complete()       # False
+p.pseudograph()    # False
+p.multigraph()     # False
+p.digraph()        # False
+p.eulerian()       # False
+p.semieulerian()   # True
+```
+
+| Method | Returns `True` if... |
+|---|---|
+| `simple()` | it has no loops or multiple edges |
+| `complete()` | there is an edge between every pair of vertices |
+| `pseudograph()` | it has at least one loop |
+| `multigraph()` | it has multiple edges between distinct vertices |
+| `digraph()` | the matrix is not symmetric (directed graph) |
+| `eulerian()` | all vertices have even degree |
+| `semieulerian()` | exactly two vertices have odd degree |
+
+### Connectivity (`Connectivity`)
+
+```python
+c = Connectivity(A)
+
+c.connected()            # True
+c.connectivity_matrix()  # [[4, 7, 7, 4], [7, 7, 8, 7], [7, 8, 7, 7], [4, 7, 7, 4]]
+```
+
+`connectivity_matrix()` computes `C = A + A² + … + Aⁿ⁻¹`. The graph is connected if all off-diagonal entries of `C` are non-zero.
+
+### Shortest path (`WeightedGraph`)
+
+```python
+W = [
+    [0, 4, 5, 0],
+    [0, 0, -3, 6],
+    [0, 0, 0, 2],
+    [0, 0, 0, 0],
+]
+g = WeightedGraph(W)
+
+g.bellman_ford(0, 3)   # ([0, 1, 2, 3], 3)  -> (path, distance)
+g.bellman_ford(3, 0)   # 'No path exists'
+g.plot_graph()         # draws the graph with its weights
+```
+
+Here the matrix is a **weight** matrix: `W[i][j]` is the weight of the edge from `i` to `j`, and 0 means there is no edge. Negative weights are allowed; if there is a negative cycle, it returns `'Negative cycle detected'`.
+
+### Isomorphism (`Isomorphism`)
+
+```python
+B = [
+    [0, 1, 1, 1],
+    [1, 0, 1, 0],
+    [1, 1, 0, 1],
+    [1, 0, 1, 0],
+]
+
+Isomorphism(A, B).isomorphic()   # True
+```
+
+It tries every permutation of the vertices, so it is only practical for small graphs.
+
+## Development
+
+```bash
+git clone https://github.com/tuusuario/graph_matrix_analysis
+cd grafomatriz
+pip install -e .
+pip install pytest
+pytest
+```
+
+## License
+
+MIT

graph_matrix_analysis-0.1.0/graph_matrix_analysis.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+graph_matrix_analysis/__init__.py
+graph_matrix_analysis/core.py
+graph_matrix_analysis.egg-info/PKG-INFO
+graph_matrix_analysis.egg-info/SOURCES.txt
+graph_matrix_analysis.egg-info/dependency_links.txt
+graph_matrix_analysis.egg-info/requires.txt
+graph_matrix_analysis.egg-info/top_level.txt

graph_matrix_analysis-0.1.0/graph_matrix_analysis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

graph_matrix_analysis-0.1.0/graph_matrix_analysis.egg-info/requires.txt

@@ -0,0 +1,2 @@
+networkx
+matplotlib

graph_matrix_analysis-0.1.0/graph_matrix_analysis.egg-info/top_level.txt

@@ -0,0 +1 @@
+graph_matrix_analysis

graph_matrix_analysis-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=77.0.0"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "graph_matrix_analysis"           # nombre único en PyPI
+version = "0.1.0"
+authors = [
+    { name="Aitor Merino", email="aitor.merino@alumni.mondragon.edu" },
+    { name="Xabier Labraga", email="xabier.labraga@alumni.mondragon.edu" }
+]
+description = "Library for analyzing graphs based on their adjacency matrix"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["graphs", "adjacency matrix", "euler", "dijkstra", "bellman-ford", "isomorphism"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "networkx",
+    "matplotlib",
+]
+

graph_matrix_analysis-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+