alonso 0.0.4__tar.gz → 0.0.6__tar.gz

{alonso-0.0.4 → alonso-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alonso
-Version: 0.0.4
+Version: 0.0.6
 Summary: Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.
 Home-page: https://github.com/frankvegadelgado/alonso
 Author: Frank Vega
@@ -22,7 +22,7 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mendive>=0.0.4
+Requires-Dist: mendive>=0.0.5
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -69,7 +69,7 @@ Given an undirected graph $G = (V, E)$, a **vertex cover** is a subset $V' \subs
 
 # Overview of the Algorithm and Its Running Time
 
-The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $\mathcal{O}(n + m)$), partitions edges in $\mathcal{O}(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursive nature, with a worst-case depth of $\mathcal{O}(m)$ if each step covers one edge, yields a total runtime of $\mathcal{O}(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = \mathcal{O}(n)$), this simplifies to $\mathcal{O}(n^4)$.
+The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$, partitions edges in $O(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $O(n^3)$ per subgraph (total $O(n^3)$), merges covers in $O(n \cdot \log n)$, and constructs the residual graph in $O(m)$. The recursive nature, with a worst-case depth of $O(m)$ if each step covers one edge, yields a total runtime of $O(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = O(n)$), this simplifies to $O(n^4)$.
 
 ---
 

{alonso-0.0.4 → alonso-0.0.6}/README.md

@@ -31,7 +31,7 @@ Given an undirected graph $G = (V, E)$, a **vertex cover** is a subset $V' \subs
 
 # Overview of the Algorithm and Its Running Time
 
-The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $\mathcal{O}(n + m)$), partitions edges in $\mathcal{O}(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursive nature, with a worst-case depth of $\mathcal{O}(m)$ if each step covers one edge, yields a total runtime of $\mathcal{O}(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = \mathcal{O}(n)$), this simplifies to $\mathcal{O}(n^4)$.
+The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$, partitions edges in $O(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $O(n^3)$ per subgraph (total $O(n^3)$), merges covers in $O(n \cdot \log n)$, and constructs the residual graph in $O(m)$. The recursive nature, with a worst-case depth of $O(m)$ if each step covers one edge, yields a total runtime of $O(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = O(n)$), this simplifies to $O(n^4)$.
 
 ---
 

{alonso-0.0.4 → alonso-0.0.6}/alonso/algorithm.py

@@ -12,7 +12,7 @@ from . import merge
 
 def find_vertex_cover(graph):
     """
-    Compute an approximate minimum vertex cover set for an undirected graph by transforming it into a chordal graph.
+    Compute an approximate minimum vertex cover set for an undirected graph.
 
     Args:
         graph (nx.Graph): A NetworkX Graph object representing the input graph.

{alonso-0.0.4 → alonso-0.0.6}/alonso/app.py

@@ -82,7 +82,7 @@ def main():
     helper.add_argument('-c', '--count', action='store_true', help='calculate the size of the vertex cover')
     helper.add_argument('-v', '--verbose', action='store_true', help='anable verbose output')
     helper.add_argument('-l', '--log', action='store_true', help='enable file logging')
-    helper.add_argument('--version', action='version', version='%(prog)s 0.0.4')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.6')
     
     # Initialize the parameters
     args = helper.parse_args()

{alonso-0.0.4 → alonso-0.0.6}/alonso/batch.py

@@ -36,7 +36,7 @@ def main():
     helper.add_argument('-c', '--count', action='store_true', help='calculate the size of the vertex cover')
     helper.add_argument('-v', '--verbose', action='store_true', help='anable verbose output')
     helper.add_argument('-l', '--log', action='store_true', help='enable file logging')
-    helper.add_argument('--version', action='version', version='%(prog)s 0.0.4')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.6')
 
     
     # Initialize the parameters

{alonso-0.0.4 → alonso-0.0.6}/alonso/test.py

@@ -34,7 +34,7 @@ def main():
     helper.add_argument('-w', '--write', action='store_true', help='write the generated random matrix to a file in the current directory')
     helper.add_argument('-v', '--verbose', action='store_true', help='anable verbose output')
     helper.add_argument('-l', '--log', action='store_true', help='enable file logging')
-    helper.add_argument('--version', action='version', version='%(prog)s 0.0.4')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.6')
     
     # Initialize the parameters
     args = helper.parse_args()

{alonso-0.0.4 → alonso-0.0.6}/alonso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alonso
-Version: 0.0.4
+Version: 0.0.6
 Summary: Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.
 Home-page: https://github.com/frankvegadelgado/alonso
 Author: Frank Vega
@@ -22,7 +22,7 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mendive>=0.0.4
+Requires-Dist: mendive>=0.0.5
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -69,7 +69,7 @@ Given an undirected graph $G = (V, E)$, a **vertex cover** is a subset $V' \subs
 
 # Overview of the Algorithm and Its Running Time
 
-The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $\mathcal{O}(n + m)$), partitions edges in $\mathcal{O}(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursive nature, with a worst-case depth of $\mathcal{O}(m)$ if each step covers one edge, yields a total runtime of $\mathcal{O}(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = \mathcal{O}(n)$), this simplifies to $\mathcal{O}(n^4)$.
+The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$, partitions edges in $O(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $O(n^3)$ per subgraph (total $O(n^3)$), merges covers in $O(n \cdot \log n)$, and constructs the residual graph in $O(m)$. The recursive nature, with a worst-case depth of $O(m)$ if each step covers one edge, yields a total runtime of $O(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = O(n)$), this simplifies to $O(n^4)$.
 
 ---
 

alonso-0.0.6/alonso.egg-info/requires.txt

@@ -0,0 +1 @@
+mendive>=0.0.5

{alonso-0.0.4 → alonso-0.0.6}/setup.py

@@ -2,12 +2,12 @@ from pathlib import Path
 
 import setuptools
 
-VERSION = "0.0.4"
+VERSION = "0.0.6"
 
 NAME = "alonso"
 
 INSTALL_REQUIRES = [
-    "mendive>=0.0.4",
+    "mendive>=0.0.5",
 ]
 
 setuptools.setup(

alonso-0.0.4/alonso.egg-info/requires.txt

@@ -1 +0,0 @@
-mendive>=0.0.4