gsimplex 0.0.2__tar.gz → 0.0.3__tar.gz

gsimplex-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Riccardo Ciucci
+
+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.

gsimplex-0.0.3/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: gsimplex
+Version: 0.0.3
+Summary: Implementation of simplex algorithm controlled by the primal-dual gap
+Author-email: Riccardo Ciucci <riccardo@ciucci.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Richie314/GapControlledSimplex
+Project-URL: Issues, https://github.com/Richie314/GapControlledSimplex/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.2.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: pulp>=3.1.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Gap controlled Simplex
+
+[![Test and publish package](https://github.com/Richie314/GapControlledSimplex/actions/workflows/pypi.yml/badge.svg)](https://github.com/Richie314/GapControlledSimplex/actions/workflows/pypi.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/gsimplex)](https://pypi.org/project/gsimplex/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gsimplex)](https://pypi.org/project/gsimplex/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/gsimplex)](https://pypi.org/project/gsimplex/)
+[![License](https://img.shields.io/pypi/l/gsimplex)](https://github.com/Richie314/GapControlledSimplex/blob/main/LICENSE)
+
+`gsimplex` is a lightweight Python package that implements a simplex solver governed by the primal-dual gap.
+It integrates directly with [pulp](https://coin-or.github.io/pulp/) and uses [numpy](https://numpy.org/) for its linear algebra routines.
+The current release supports continuous linear programming problems; mixed-integer support may be added in a future version.
+
+## Features
+
+- `pulp` compatible solver backend
+- Gap-controlled primal/dual simplex algorithms
+- Easy installation from PyPI or source
+- Built-in benchmark downloader for Plato and Netlib test sets
+
+## Installation
+
+Install from PyPI:
+
+```bash
+python -m pip install gsimplex
+```
+
+Install from source for local development:
+
+```bash
+git clone https://github.com/Richie314/GapControlledSimplex.git
+cd GapControlledSimplex
+python -m pip install -e .
+python -m pip install -e .[dev]
+```
+
+Run the test suite with:
+
+```bash
+python -m pytest
+```
+
+## Usage
+```python
+from pulp import LpVariable, LpProblem, LpMaximize
+from gsimplex.solvers import PrimalSimplex
+
+x1 = LpVariable("x1", lowBound=0, upBound=1)
+x2 = LpVariable("x2", lowBound=0, upBound=3)
+
+problem = LpProblem("Problem", LpMaximize)
+problem += x1 + x2
+problem += x1 + x2 <= 2
+problem += x1 <= 1
+problem += x2 <= 3
+problem += x1 >= 0
+problem += x2 >= 0
+
+solver = PrimalSimplex()
+problem.solve(solver)
+
+print("Optimal value:", problem.objective.value()) # 2.0
+print("Solution:", [var.varValue for var in problem.variables()]) # [1.0, 1.0]
+```
+
+## Download benchmark problems
+
+This package installs a command-line helper called `gsimplex-download-benchmarks`.
+It downloads the Plato and Netlib benchmark sets into a local directory, so you can test the solver on real LP problems.
+
+By default, benchmark files are saved under the `benchmark/` directory in the current working directory. Plato files are stored in `benchmark/plato/`, and Netlib files are stored in `benchmark/netlib/`.
+
+### Download all benchmarks
+
+```bash
+gsimplex-download-benchmarks
+```
+
+### Download only one benchmark set
+
+```bash
+gsimplex-download-benchmarks --plato True --netlib False
+# or
+gsimplex-download-benchmarks --plato False --netlib True
+```
+
+> Note: the CLI uses boolean flags for `--plato` and `--netlib`, so set the one you want to disable to `False`.
+
+### Change the destination directory
+
+```bash
+gsimplex-download-benchmarks --dir benchmark
+```
+
+### Quiet mode
+
+```bash
+gsimplex-download-benchmarks --quiet
+```
+
+If you installed the package editable with `pip install -e .`, the command will be available immediately.

gsimplex-0.0.3/README.md

@@ -0,0 +1,101 @@
+# Gap controlled Simplex
+
+[![Test and publish package](https://github.com/Richie314/GapControlledSimplex/actions/workflows/pypi.yml/badge.svg)](https://github.com/Richie314/GapControlledSimplex/actions/workflows/pypi.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/gsimplex)](https://pypi.org/project/gsimplex/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gsimplex)](https://pypi.org/project/gsimplex/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/gsimplex)](https://pypi.org/project/gsimplex/)
+[![License](https://img.shields.io/pypi/l/gsimplex)](https://github.com/Richie314/GapControlledSimplex/blob/main/LICENSE)
+
+`gsimplex` is a lightweight Python package that implements a simplex solver governed by the primal-dual gap.
+It integrates directly with [pulp](https://coin-or.github.io/pulp/) and uses [numpy](https://numpy.org/) for its linear algebra routines.
+The current release supports continuous linear programming problems; mixed-integer support may be added in a future version.
+
+## Features
+
+- `pulp` compatible solver backend
+- Gap-controlled primal/dual simplex algorithms
+- Easy installation from PyPI or source
+- Built-in benchmark downloader for Plato and Netlib test sets
+
+## Installation
+
+Install from PyPI:
+
+```bash
+python -m pip install gsimplex
+```
+
+Install from source for local development:
+
+```bash
+git clone https://github.com/Richie314/GapControlledSimplex.git
+cd GapControlledSimplex
+python -m pip install -e .
+python -m pip install -e .[dev]
+```
+
+Run the test suite with:
+
+```bash
+python -m pytest
+```
+
+## Usage
+```python
+from pulp import LpVariable, LpProblem, LpMaximize
+from gsimplex.solvers import PrimalSimplex
+
+x1 = LpVariable("x1", lowBound=0, upBound=1)
+x2 = LpVariable("x2", lowBound=0, upBound=3)
+
+problem = LpProblem("Problem", LpMaximize)
+problem += x1 + x2
+problem += x1 + x2 <= 2
+problem += x1 <= 1
+problem += x2 <= 3
+problem += x1 >= 0
+problem += x2 >= 0
+
+solver = PrimalSimplex()
+problem.solve(solver)
+
+print("Optimal value:", problem.objective.value()) # 2.0
+print("Solution:", [var.varValue for var in problem.variables()]) # [1.0, 1.0]
+```
+
+## Download benchmark problems
+
+This package installs a command-line helper called `gsimplex-download-benchmarks`.
+It downloads the Plato and Netlib benchmark sets into a local directory, so you can test the solver on real LP problems.
+
+By default, benchmark files are saved under the `benchmark/` directory in the current working directory. Plato files are stored in `benchmark/plato/`, and Netlib files are stored in `benchmark/netlib/`.
+
+### Download all benchmarks
+
+```bash
+gsimplex-download-benchmarks
+```
+
+### Download only one benchmark set
+
+```bash
+gsimplex-download-benchmarks --plato True --netlib False
+# or
+gsimplex-download-benchmarks --plato False --netlib True
+```
+
+> Note: the CLI uses boolean flags for `--plato` and `--netlib`, so set the one you want to disable to `False`.
+
+### Change the destination directory
+
+```bash
+gsimplex-download-benchmarks --dir benchmark
+```
+
+### Quiet mode
+
+```bash
+gsimplex-download-benchmarks --quiet
+```
+
+If you installed the package editable with `pip install -e .`, the command will be available immediately.

{gsimplex-0.0.2 → gsimplex-0.0.3}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gsimplex"
-version = "0.0.2"
+version = "0.0.3"
 authors = [
   { name="Riccardo Ciucci", email="riccardo@ciucci.dev" },
 ]
-description = "Implementation of simplex algorithm contrelled by the primal-dual gap"
+description = "Implementation of simplex algorithm controlled by the primal-dual gap"
 readme = "README.md"
 requires-python = ">=3.12"
 classifiers = [
@@ -24,11 +24,9 @@ dependencies = [
 ]
 
 [project.scripts]
-gsimplex = "gsimplex.main:__main"
-gsimplex-demo = "gsimplex.demo:demo"
-gsimplex-download-netlib = "gsimplex.benchmarks.netlib:main"
+gsimplex = "gsimplex.__main__:main"
 gsimplex-emps = "gsimplex.benchmarks.netlib_emps:__main"
-gsimplex-download-plato = "gsimplex.benchmarks.plato:main"
+gsimplex-download-benchmarks = "gsimplex.benchmarks.__main__:main"
 
 [project.urls]
 Homepage = "https://github.com/Richie314/GapControlledSimplex"

gsimplex-0.0.3/src/gsimplex/__init__.py

@@ -0,0 +1,3 @@
+from gsimplex.exception import GsimplexException
+from gsimplex.basis import Basis
+from gsimplex.vertex import Vertex

gsimplex-0.0.2/src/gsimplex/main.py → gsimplex-0.0.3/src/gsimplex/__main__.py

@@ -1,16 +1,25 @@
+#!/usr/bin/env python3
+
 import argparse
 import sys
 
-from gsimplex.problem import Problem
-from gsimplex.solvers.solver_interface import ISolver
-from gsimplex.solvers.primal_simplex import PrimalSimplex
-from gsimplex.solvers.dual_simplex import DualSimplex
-from gsimplex.solvers.gap_simplex import GapSimplex
+from gsimplex.solvers import (
+    ISolver,
+    PrimalSimplex,
+    DualSimplex,
+    GapDoubleSimplex,
+)
 from gsimplex.tools.parser import ProblemParser
 
-def __main():
+def main():
+    """
+    Command-line entry point for the gsimplex solver.
+
+    :return: Exit code for the program.
+    :rtype: int
+    """
     solvers = {
-        'gsimplex' : GapSimplex,
+        'gsimplex' : GapDoubleSimplex,
         'psimplex': PrimalSimplex,
         'dsimplex': DualSimplex,
     }
@@ -34,4 +43,4 @@ def __main():
     return 0
 
 if __name__ == "__main__":
-    sys.exit(__main())
+    sys.exit(main())

gsimplex-0.0.3/src/gsimplex/basis.py

@@ -0,0 +1,316 @@
+from pulp import LpProblem, LpConstraint, LpVariable
+from pulp.constants import LpConstraintEQ, LpConstraintLE, LpConstraintGE
+from typing import List, Tuple, Optional, Union
+import numpy as np
+
+class ConstraintSet(List[LpConstraint]):
+    """
+    A set of linear constraints for a linear programming problem.
+    """
+
+    def __init__(self, *constraints: LpConstraint):
+        super().__init__(constraints)
+
+    def _compute_system(self, problem: LpProblem) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Compute the system of equations defined by the constraints in this set.
+
+        :param problem: The linear programming problem that defines the variables.
+        :type problem: LpProblem
+        :return: A tuple containing the constraint coefficient matrix and right-hand side vector.
+        :rtype: Tuple[np.ndarray, np.ndarray]
+        """
+
+        a_B = np.array([ConstraintSet.constraint_to_row(constraint, problem) for constraint in self])
+        b_B = np.array([ConstraintSet.constraint_to_linear_term(constraint) for constraint in self])
+        return a_B, b_B
+
+    def _compute_primal_point(self, problem: LpProblem) -> np.ndarray:
+        """
+        Compute the primal point *x* corresponding to this basis by solving the basis system (A_B x = b_B).
+
+        :param problem: The linear programming problem used to determine the active variables.
+        :type problem: LpProblem
+        :return: The primal solution vector associated with the current basis.
+        :rtype: np.ndarray
+        """
+
+        n = problem.numVariables()
+        assert len(self) >= n, "Not enough constraints to form a square matrix"
+
+        a_B, b_B = self._compute_system(problem)
+        return np.linalg.solve(a_B, b_B)
+
+    def _compute_dual_point(self, problem: LpProblem) -> np.ndarray:
+        """
+        Compute the dual point *y* corresponding to this basis by solving the dual system.
+
+        :param problem: The linear programming problem whose objective determines the dual solution.
+        :type problem: LpProblem
+        :return: The dual solution values for the basic constraints.
+        :rtype: np.ndarray
+        """
+
+        n = problem.numVariables()
+        assert len(self) == n, f"Constraint number mismatch: {len(self)} != {n}"
+
+        m = problem.numConstraints()
+        assert len(self) <= m, "Too many constraints in basis"
+
+        c = Basis.get_objective_function(problem)
+        assert len(c) == n
+
+        a_B, _ = self._compute_system(problem)
+        y_B = np.linalg.solve(a_B.T, c)
+
+        return y_B
+    
+    @staticmethod
+    def __get_constraint_sense(constraint: LpConstraint, 
+                               convert_eq_to: int = LpConstraintLE,
+                               ) -> int:
+        """
+        Extracts the sense from a `LpConstraint`.
+
+        :param constraint: The constraint to extract the sense from.
+        :type constraint: LpConstraint
+        :param convert_eq_to: How to treat equality constraints when converting them.
+        :type convert_eq_to: int
+        :return: Either `pulp.LpConstraintGE` or `pulp.LpConstraintLE`.
+        :rtype: int
+        """
+
+        sense = constraint.sense
+        if sense == LpConstraintEQ:
+            sense = convert_eq_to
+        
+        if sense != LpConstraintLE and sense != LpConstraintGE:
+            raise ValueError(f"Unsupported constraint sense: {constraint.sense}")
+        
+        return sense
+    
+    @staticmethod
+    def constraint_to_row(constraint: LpConstraint, 
+                          problem: LpProblem, 
+                          convert_eq_to: int = LpConstraintLE,
+                          ) -> np.ndarray:
+        """
+        Convert a constraint to a numpy array of coefficients corresponding to the given variables.
+
+        :param constraint: The constraint to convert.
+        :type constraint: LpConstraint
+        :param problem: The linear programming problem containing the variables.
+        :type problem: LpProblem
+        :param convert_eq_to: How to treat equality constraints when converting them.
+        :type convert_eq_to: int
+        :return: A numpy vector of coefficients corresponding to problem variables.
+        :rtype: np.ndarray
+        """
+
+        sense = ConstraintSet.__get_constraint_sense(constraint, convert_eq_to)
+        return -sense * np.array([constraint.get(var, 0) for var in problem.variables()])
+    
+    @staticmethod
+    def constraint_to_linear_term(constraint: LpConstraint, 
+                                  convert_eq_to: int = LpConstraintLE,
+                                  ) -> float:
+        """
+        Extract the linear term from a constraint in the form Ax <= b.
+
+        :param constraint: The constraint to convert.
+        :type constraint: LpConstraint
+        :param convert_eq_to: How to treat equality constraints when converting them.
+        :type convert_eq_to: int
+        :return: The right-hand side constant term for the converted constraint.
+        :rtype: float
+        """
+
+        """
+        Pulp memorizes data in the form Ax + constant <=> 0
+        Hence b is
+            * -constant if <=
+            *  constant if >=
+            * any of the above if == (treated as convert_eq_to says)
+        """
+        sense = ConstraintSet.__get_constraint_sense(constraint, convert_eq_to)
+        
+        """
+        if sense == LpConstraintLE:
+            return -constraint.constant
+        else:
+            return constraint.constant
+        """
+        return sense * constraint.constant
+    
+    def has_named_constraints(self, names: List[str]) -> bool:
+        """
+        Check whether this vertex contains any of the requested constraint names.
+
+        :param names: A list of constraint names to search for.
+        :type names: List[str]
+        :return: True if the vertex includes at least one named constraint.
+        :rtype: bool
+        """
+        for c in self:
+            if c.name is not None and c.name in names:
+                return True
+            
+        return False
+    
+    @staticmethod
+    def get_objective_function(problem: LpProblem) -> np.ndarray:
+        """
+        Extract the objective function coefficients from the problem.
+
+        :param problem: The linear programming problem containing the objective.
+        :type problem: LpProblem
+        :return: The objective coefficients vector aligned with problem variables.
+        :rtype: np.ndarray
+        """
+
+        assert problem.objective, "Problem must have an objective function"
+        return np.array([problem.objective.get(var, 0) for var in problem.variables()])
+    
+
+class Basis(ConstraintSet):
+    """
+    A basis for a linear programming problem, represented as a set of constraints.
+    """
+
+    def __init__(self, problem: LpProblem, *constraints: LpConstraint):
+        """
+        Initialize a basis with the specified constraints for a linear problem.
+
+        :param problem: The linear programming problem for this basis.
+        :type problem: LpProblem
+        :param constraints: The active basis constraints.
+        :type constraints: LpConstraint
+        """
+
+        super().__init__(*constraints)
+
+        assert problem.objective, "Problem must have an objective function"
+
+        self.n = problem.numVariables()
+        assert self.n > 0, "Problem must have at least one variable"
+        assert len(self) == self.n, f"Basis must have same number of constraints as problem dimension: {len(self)} ≠ {self.n}"
+
+        self.problem = problem
+
+        self.__x: Optional[np.ndarray] = None
+        self.__y: Optional[np.ndarray] = None
+
+    def _set_primal_vars(self, x: Union[np.ndarray, List[float]]) -> np.ndarray:
+        """
+        Store and assign the primal solution values to problem variables.
+
+        :param x: The primal solution values for all problem variables.
+        :type x: Union[np.ndarray, List[float]]
+        :return: The stored primal solution as a NumPy array.
+        :rtype: np.ndarray
+        """
+
+        if not isinstance(x, np.ndarray):
+            x = np.array(x)
+
+        assert len(x) == self.problem.numVariables()
+
+        self.__x = x
+        for i, var in enumerate(self.variables):
+            var.varValue = self.__x[i]
+
+        return self.__x
+    
+    @property
+    def x(self) -> np.ndarray:
+        """
+        Get the primal point corresponding to this basis.
+
+        :return: The primal solution vector for the basis.
+        :rtype: np.ndarray
+        """
+
+        if self.__x is not None:
+            return self.__x
+        
+        x = self._compute_primal_point(self.problem)
+        return self._set_primal_vars(x)
+    
+
+    def _set_dual_vars(self, y_B: Union[np.ndarray, List[float]]) -> np.ndarray:
+        """
+        Store the dual solution values and map them into the full constraint vector.
+
+        :param y_B: The dual values for the basic constraints.
+        :type y_B: Union[np.ndarray, List[float]]
+        :return: The full dual solution vector mapped to all problem constraints.
+        :rtype: np.ndarray
+        """
+
+        assert len(y_B) == self.problem.numVariables()
+
+        self.__y =  np.zeros(self.problem.numConstraints())
+        for i, y_i in enumerate(y_B):
+            constraint = self[i]
+            self.__y[self.global_index(constraint)] = y_i
+
+        return self.__y
+    
+    @property
+    def y(self) -> np.ndarray:
+        """
+        Get the dual point corresponding to this basis.
+
+        :return: The dual solution vector for all problem constraints.
+        :rtype: np.ndarray
+        """
+
+        if self.__y is not None:
+            return self.__y
+        
+        y_B = self._compute_dual_point(self.problem)
+        return self._set_dual_vars(y_B)
+
+    @property
+    def variables(self) -> List[LpVariable]:
+        return self.problem.variables()
+
+    @property
+    def indices(self) -> List[int]:
+        return [self.global_index(c) for c in self]
+
+    @property
+    def non_basis_indices(self) -> List[int]:
+        return [self.global_index(c) for c in self.non_basis]
+    
+    @property
+    def all_constraints(self) -> List[LpConstraint]:
+        return list(self.problem.constraints.values())
+
+    def global_index(self, constraint: LpConstraint) -> int:
+        """
+        Return the global index of a constraint in the original problem ordering.
+
+        :param constraint: The constraint whose index is requested.
+        :type constraint: LpConstraint
+        :return: The zero-based index of the constraint in the problem.
+        :rtype: int
+        """
+
+        return self.all_constraints.index(constraint)
+
+    @property
+    def non_basis(self) -> ConstraintSet:
+        """
+        Return the set of constraints that are not in the basis.
+        """
+
+        return ConstraintSet(*[c for c in self.all_constraints if c not in self])
+    
+    
+    def __str__(self) -> str:
+        s  = f'x = {self.x}\n'
+        s += f'y = {self.y}\n'
+        for c in self:
+            s += f'{c}\t→ {c.value():.4}\n'
+        return s