gsimplex 0.0.2__py3-none-any.whl

gsimplex/benchmarks/plato.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+
+import asyncio
+import sys
+import argparse
+from typing import Dict, List, Optional, Tuple
+
+from gsimplex.benchmarks.downloader import Downloader
+
+
+class PlatoDownloader(Downloader):
+    BASE_URL = "https://plato.asu.edu/ftp/lptestset/"
+    
+    async def download_plato_benchmarks_async(self, problem_names: List[str]) -> Dict[str, str]:
+        files: List[Tuple[str, str, str, Optional[str]]] = [
+            (f"{self.BASE_URL}{name}.mps.bz2", name, f"plato/{name}.mps.bz2", None)
+            for name in problem_names
+            if name.strip()
+        ]
+        return await self.download_many_async(files)
+
+async def download_plato_benchmarks(dir: Optional[str] = None, quiet: bool = False) -> bool:
+    downloader = PlatoDownloader(benchmark_dir=dir, quiet=quiet)
+    
+    # All Plato problems (flattened)
+    problem_names = [
+        "Dual2_5000", "L2CTA3D", "Primal2_1000", "a2864", "bharat",
+        "brazil3", "chromaticindex1024-7", "datt256_lp", "dlr1", "dlr2",
+        "ex10", "fhnw-binschedule1", "graph40-40", "irish-electricity",
+        "neos-3025225", "neos-5052403-cygnet", "neos-5251015",
+        "physiciansched3-3", "qap15", "rmine15", "s82", "s100", "s250r10",
+        "savsched1", "scpm1", "set-cover-model", "square41",
+        "supportcase10", "supportcase19", "thk_48", "thk_63",
+        "tpl-tub-ws1617", "woodlands09"
+    ]
+    
+    if not quiet:
+        print(f"Downloading {len(problem_names)} Plato problems...")
+    results = await downloader.download_plato_benchmarks_async(problem_names)
+    if not quiet:
+        print(f"Downloaded {len(results)} problems successfully")
+
+    return len(results) == len(problem_names)
+
+def main():
+    parser = argparse.ArgumentParser(description="Download Plato benchmarks")
+    parser.add_argument('--quiet', action='store_true', help='Run in quiet mode')
+    parser.add_argument('--dir', type=str, default=None, help='Directory to save benchmarks')
+    args = parser.parse_args()
+
+    esit = asyncio.run(download_plato_benchmarks(quiet=args.quiet, dir=args.dir))
+    return 0 if esit else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

gsimplex/demo.py

@@ -0,0 +1,54 @@
+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
+
+def __solve_and_print(solver: ISolver, problem: Problem, B: list[int]|None = None):
+    solution = None
+    try:
+        solution = solver.maximize(problem, B)
+    except Exception as e:
+        print(str(e))
+        return
+
+    if solution is None:
+        print("Problem is unbounded or infeasible")
+        return
+
+    print(f"x = [{'; '.join(map(str, solution.x))}]")
+    print(f"y = [{'; '.join(map(str, solution.y))}]")
+
+    try:
+        print(f"c^T * x = {solution.point.primal_value()}")
+    except Exception as e:
+        print(str(e))
+
+    try:
+        print(f"y^T * b = {solution.point.dual_value()}")
+    except Exception as e:
+        print(str(e))
+
+def demo():
+    problem = Problem.from_ab_rows(
+        [ 4.0, 5.0,  2.0],
+        [ 0.0, 0.6,  0.8, 500.0],
+        [-1.0, 2.0,  0.0,   0.0],
+        [ 1.0, 0.0, -1.0,   0.0]
+    ).enforce_positivity()
+
+    print("=== Primal Simplex ===")
+    __solve_and_print(PrimalSimplex(), problem, B=[0, 3, 4])
+    print()
+    print()
+
+    print("=== Dual Simplex ===")
+    __solve_and_print(DualSimplex(), problem)
+    print()
+    print()
+
+    print("=== Gap-Controlled Simplex ===")
+    __solve_and_print(GapSimplex(), problem, B=[0, 3, 4])
+
+if __name__ == "__main__":
+    demo()

gsimplex/main.py

@@ -0,0 +1,37 @@
+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.tools.parser import ProblemParser
+
+def __main():
+    solvers = {
+        'gsimplex' : GapSimplex,
+        'psimplex': PrimalSimplex,
+        'dsimplex': DualSimplex,
+    }
+
+    parser = argparse.ArgumentParser(description="")
+    parser.add_argument('--quiet', action='store_true', 
+                        help='Run in quiet mode')
+    parser.add_argument('--problem', type=str, required=True, 
+                        help='Name of the problem to solve or path to it')
+    parser.add_argument('--solver', default='gsimplex', type=str, choices=solvers.keys(), 
+                        help='Algorithm to use to solve the problem')
+    args = parser.parse_args()
+
+
+    problem = ProblemParser.load_mps_from_file(args.problem)
+    print(f"{problem=}")
+
+    solver: ISolver = solvers[args.solver]()
+    print(f"{solver=}")
+
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(__main())

gsimplex/problem.py

@@ -0,0 +1,46 @@
+import numpy as np
+from typing import List, Union
+
+class Problem:
+    """
+    Linear programming problem in the form max { c^T x } subject to Ax <= b, x >= 0
+    """
+    
+    def __init__(self, 
+                 c: Union[List[float], np.ndarray], 
+                 A: Union[List[List[float]], np.ndarray], 
+                 b: Union[List[float], np.ndarray]
+                 ):
+        self.c = np.array(c, dtype=float)
+        self.A = np.array(A, dtype=float)
+        self.b = np.array(b, dtype=float)
+
+        if self.c.shape[0] != self.A.shape[1]:
+            raise ValueError("c must have same length as A columns")
+
+        if self.A.shape[0] != self.b.shape[0]:
+            raise ValueError("A rows must match b length")
+
+    @property
+    def dimension(self) -> int:
+        return self.A.shape[1]
+
+    @property
+    def constraints(self) -> int:
+        return self.A.shape[0]
+
+    @classmethod
+    def from_arrays(cls, c: List[float], A: List[List[float]], b: List[float]) -> 'Problem':
+        return cls(c, A, b)
+
+    @classmethod
+    def from_ab_rows(cls, c: List[float], *ab_rows: List[float]) -> 'Problem':
+        A = [row[:-1] for row in ab_rows]
+        b = [row[-1] for row in ab_rows]
+        return cls(c, A, b)
+
+    def enforce_positivity(self) -> 'Problem':
+        I = np.eye(self.dimension)
+        new_b = np.concatenate([self.b, np.zeros(self.dimension)])
+        new_A = np.vstack([self.A, -I])
+        return Problem(self.c, new_A, new_b)

gsimplex/solution.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from gsimplex.vertex import Vertex
+
+@dataclass
+class Solution:
+    point: Vertex
+    iteration_count: int
+    initial_iterations: int = 0
+
+    @property
+    def problem(self):
+        return self.point.problem
+
+    @property
+    def basis(self):
+        return self.point.basis
+
+    @property
+    def x(self):
+        return self.point.x
+
+    @property
+    def y(self):
+        return self.point.y

gsimplex/solvers/__init__.py

@@ -0,0 +1 @@
+# Solvers package

gsimplex/solvers/criss_cross.py

@@ -0,0 +1,13 @@
+from typing import Optional, Tuple, List
+
+from gsimplex.solvers.iterative_solver import IterativeSolver
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+from gsimplex.solution import Solution
+
+class CrissCross(IterativeSolver):
+    def get_starting_point(self, problem: Problem, given_basis: Optional[List[int]] = None) -> Tuple[Optional[Vertex], int]:
+        raise NotImplementedError()
+
+    def maximize(self, problem: Problem, start_basis: Optional[List[int]] = None) -> Optional[Solution]:
+        raise NotImplementedError()

gsimplex/solvers/dual_simplex.py

@@ -0,0 +1,104 @@
+import numpy as np
+from typing import Optional, Tuple, List
+
+from gsimplex.solvers.iterative_solver import IterativeSolver
+from gsimplex.solvers.simplex_interface import ISimplex
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+from gsimplex.solution import Solution
+
+class DualSimplex(IterativeSolver, ISimplex):
+    @staticmethod
+    def iteration(vertex: Vertex) -> Optional[Vertex]:
+        if not vertex.is_dual_feasible():
+            return None
+
+        if vertex.is_primal_feasible():
+            return vertex  # Optimal
+
+        # Entering index (Bland rule)
+        infeas = vertex.primal_infeasible_rows()
+        if not infeas:
+            return vertex
+        k, _ = infeas[0]
+
+        Ak = vertex.problem.A[k]
+
+        # Leaving index (Minimum ratio + Bland rule)
+        ratios = []
+        for i in vertex.basis:
+            idx = np.where(vertex.basis == i)[0][0]
+            den = Ak @ vertex.W[:, idx]
+            if den < -Vertex.ABSOLUTE_TOLERANCE:
+                ratios.append((i, -vertex.y[i] / den))
+
+        if not ratios:
+            return None  # Unbounded
+
+        ratios.sort(key=lambda x: x[1])
+        h, _ = ratios[0]
+
+        new_basis = np.setdiff1d(vertex.basis, [h])
+        new_basis = np.append(new_basis, k)
+
+        return Vertex(vertex.problem, new_basis)
+
+    def maximize(self, problem: Problem, start_basis: Optional[List[int]] = None) -> Optional[Solution]:
+        current, initial_iterations = self.get_starting_point(problem, start_basis)
+
+        iterations = 0
+        while current is not None and self._check_iteration_count(iterations):
+            if current.is_optimal_point():
+                return Solution(
+                    point=current,
+                    iteration_count=iterations,
+                    initial_iterations=initial_iterations
+                )
+            current = self.iteration(current)
+            iterations += 1
+
+        return None
+
+    def make_feasible(self, vertex: Vertex) -> Optional[Vertex]:
+        v = vertex
+        while not v.is_dual_feasible():
+            dual_infeas = v.dual_infeasible_values()
+            if not dual_infeas:
+                break
+            p, _ = dual_infeas[0]
+
+            d = -v.W @ v.problem.A[p]
+
+            # Entering index
+            min_pivot = float('inf')
+            q = -1
+            for i in v.non_basis:
+                pivot = v.problem.A[i] @ d
+                if pivot <= -Vertex.ABSOLUTE_TOLERANCE and abs(pivot) < min_pivot:
+                    min_pivot = abs(pivot)
+                    q = i
+
+            if q == -1:
+                raise ValueError("Unbounded problem")
+
+            new_basis = np.setdiff1d(v.basis, [p])
+            new_basis = np.append(new_basis, q)
+            v = Vertex(v.problem, new_basis)
+
+        return v
+
+    def get_feasible_vertex(self, problem: Problem) -> Optional[Tuple[Vertex, int]]:
+        initial_point = Vertex(problem, np.arange(problem.dimension))
+        dual_feasible = self.make_feasible(initial_point)
+        if dual_feasible is None:
+            return None
+        return dual_feasible, 0
+
+    def get_starting_point(self, problem: Problem, given_basis: Optional[List[int]] = None) -> Tuple[Optional[Vertex], int]:
+        if given_basis is not None:
+            return Vertex(problem, given_basis), 0
+
+        phase_one = self.get_feasible_vertex(problem)
+        if phase_one is None:
+            return None, 0
+        return phase_one

gsimplex/solvers/gap_simplex.py

@@ -0,0 +1,74 @@
+from typing import Optional, Tuple, List
+
+from gsimplex.solvers.iterative_solver import IterativeSolver
+from gsimplex.solvers.simplex_interface import ISimplex
+from gsimplex.solvers.primal_simplex import PrimalSimplex
+from gsimplex.solvers.dual_simplex import DualSimplex
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+from gsimplex.solution import Solution
+
+class GapSimplex(IterativeSolver, ISimplex):
+    def __init__(self):
+        super().__init__()
+        self._primal_simplex = PrimalSimplex()
+        self._dual_simplex = DualSimplex()
+
+    def maximize(self, problem: Problem, start_basis: Optional[List[int]] = None) -> Optional[Solution]:
+        primal_vertex, initial_primal = self.get_starting_point(problem, start_basis)
+        dual_vertex, initial_dual = self._dual_simplex.get_starting_point(problem)
+
+        if (primal_vertex is None or not primal_vertex.is_primal_feasible() or
+            dual_vertex is None or not dual_vertex.is_dual_feasible()):
+            return None
+
+        primal_iterations = 0
+        dual_iterations = 0
+
+        while (not primal_vertex.is_optimal_point() and self._check_iteration_count(primal_iterations) and
+               not dual_vertex.is_optimal_point() and self._check_iteration_count(dual_iterations)):
+
+            gap, rel_gap, dual_val, primal_val = Vertex.gap(dual_vertex, primal_vertex)
+
+            print(f"Gap: {gap} = {dual_val} - {primal_val}")
+            if rel_gap is not None:
+                print(f"Relative gap: {rel_gap}")
+
+            if primal_vertex.is_primal_degenerate():
+                new_primal = self._primal_simplex.make_feasible(dual_vertex)
+                if new_primal is not None and new_primal.primal_value() > primal_val:
+                    primal_vertex = new_primal
+
+            if dual_vertex.is_dual_degenerate():
+                new_dual = self._dual_simplex.make_feasible(primal_vertex)
+                if new_dual is not None and new_dual.dual_value() < dual_val:
+                    dual_vertex = new_dual
+
+            primal_vertex = PrimalSimplex.iteration(primal_vertex)
+            if primal_vertex is None or primal_vertex.is_optimal_point():
+                break
+            primal_iterations += 1
+
+            dual_vertex = DualSimplex.iteration(dual_vertex)
+            if dual_vertex is None or dual_vertex.is_optimal_point():
+                break
+            dual_iterations += 1
+
+        if primal_vertex is None or dual_vertex is None:
+            return None
+
+        optimal_point = primal_vertex if primal_vertex.is_optimal_point() else dual_vertex
+        return Solution(
+            point=optimal_point,
+            iteration_count=max(primal_iterations, dual_iterations),
+            initial_iterations=initial_primal + initial_dual
+        )
+
+    def get_feasible_vertex(self, problem: Problem) -> Optional[Tuple[Vertex, int]]:
+        return self._primal_simplex.get_feasible_vertex(problem)
+
+    def get_starting_point(self, problem: Problem, given_basis: Optional[List[int]] = None) -> Tuple[Optional[Vertex], int]:
+        return self._primal_simplex.get_starting_point(problem, given_basis)
+
+    def make_feasible(self, vertex: Vertex) -> Optional[Vertex]:
+        raise NotImplementedError()

gsimplex/solvers/iterative_solver.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Tuple
+
+from gsimplex.solvers.solver_interface import ISolver
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+
+class IterativeSolver(ISolver, ABC):
+    def __init__(self):
+        self.max_iterations: Optional[int] = None
+
+    def _check_iteration_count(self, iterations: int) -> bool:
+        return self.max_iterations is None or iterations <= self.max_iterations
+
+    @abstractmethod
+    def get_starting_point(self, 
+                           problem: Problem, 
+                           given_basis: Optional[list[int]] = None
+                           ) -> Tuple[Optional[Vertex], int]:
+        pass

gsimplex/solvers/primal_simplex.py

@@ -0,0 +1,136 @@
+import numpy as np
+from typing import Optional, Tuple, List
+
+from gsimplex.solvers.iterative_solver import IterativeSolver
+from gsimplex.solvers.simplex_interface import ISimplex
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+from gsimplex.solution import Solution
+
+class PrimalSimplex(IterativeSolver, ISimplex):
+    @staticmethod
+    def iteration(vertex: Vertex) -> Optional[Vertex]:
+        if not vertex.is_primal_feasible():
+            return None
+
+        # Leaving index (Bland rule)
+        dual_infeas = vertex.dual_infeasible_values()
+        if not dual_infeas:
+            return vertex  # Optimal
+
+        h, _ = dual_infeas[0]
+
+        # Wh is the h-th column of -A_B^-1
+        h_idx = np.where(vertex.basis == h)[0][0]
+        Wh = vertex.W[:, h_idx]
+
+        # Entering index (Bland rule)
+        non_basis = vertex.non_basis
+        ratios = []
+        for i in non_basis:
+            den = vertex.problem.A[i] @ Wh
+            if den > Vertex.ABSOLUTE_TOLERANCE:
+                num = vertex.problem.b[i] - vertex.problem.A[i] @ vertex.x
+                ratios.append((i, num / den))
+
+        if not ratios:
+            return None  # Unbounded
+
+        ratios.sort(key=lambda x: x[1])
+        k, _ = ratios[0]
+
+        new_basis = np.setdiff1d(vertex.basis, [h])
+        new_basis = np.append(new_basis, k)
+
+        return Vertex(vertex.problem, new_basis)
+
+    def get_starting_point(self, problem: Problem, given_basis: Optional[List[int]] = None) -> Tuple[Optional[Vertex], int]:
+        if given_basis is not None:
+            return Vertex(problem, given_basis), 0
+
+        feasible = self.get_feasible_vertex(problem)
+        if feasible is None:
+            return None, 0
+        return feasible
+
+    def maximize(self, problem: Problem, start_basis: Optional[List[int]] = None) -> Optional[Solution]:
+        current, initial_iterations = self.get_starting_point(problem, start_basis)
+
+        iterations = 0
+        while current is not None and self._check_iteration_count(iterations):
+            if current.is_optimal_point():
+                return Solution(
+                    point=current,
+                    iteration_count=iterations,
+                    initial_iterations=initial_iterations
+                )
+            current = self.iteration(current)
+            iterations += 1
+
+        return None
+
+    def make_feasible(self, vertex: Vertex) -> Optional[Vertex]:
+        v = vertex
+        while not v.is_primal_feasible():
+            infeas = v.primal_infeasible_rows()
+            if not infeas:
+                break
+            k, _ = min(infeas, key=lambda x: x[1])
+
+            Ak = v.problem.A[k]
+
+            # Leaving index (Bland rule)
+            h = -1
+            for i in v.basis:
+                idx = np.where(v.basis == i)[0][0]
+                if Ak @ v.W[:, idx] < 0:
+                    h = i
+                    break
+            if h == -1:
+                return None
+
+            new_basis = np.setdiff1d(v.basis, [h])
+            new_basis = np.append(new_basis, k)
+            v = Vertex(v.problem, new_basis)
+
+        return v
+
+    def get_feasible_vertex(self, problem: Problem) -> Optional[Tuple[Vertex, int]]:
+        n = problem.dimension
+        m = problem.constraints
+
+        initial_basis = np.arange(n)
+        initial_vertex = Vertex(problem, initial_basis)
+
+        if initial_vertex.is_primal_feasible():
+            return initial_vertex, 0
+
+        # Auxiliary problem
+        rp = initial_vertex.primal_residuals()
+        V = initial_vertex.non_basis[rp[initial_vertex.non_basis] < 0]
+
+        # Number of auxiliary variables
+        k = len(V)
+
+        # Build matrix of the auxiliary problem
+        aux_A = np.zeros((m + k, n + k))
+        aux_A[:m, :n] = problem.A
+        aux_A[m:, n:] = -np.eye(k)
+        for idx, i in enumerate(V):
+            aux_A[i, n + idx] = -1
+
+        aux_b = np.concatenate([problem.b, np.zeros(k)])
+        aux_c = np.concatenate([np.zeros(n), -np.ones(k)])
+
+        aux_problem = Problem(aux_c, aux_A, aux_b)
+
+        aux_solution = self.maximize(aux_problem, initial_vertex.basis.tolist() + V.tolist())
+        if aux_solution is None or not aux_solution.point.is_optimal_point() or aux_solution.point.primal_value() < 0:
+            return None
+
+        new_basis = aux_solution.basis[:n]
+        new_vertex = Vertex(problem, new_basis)
+        if not new_vertex.is_primal_feasible():
+            raise ValueError("Auxiliary problem failed")
+
+        return new_vertex, aux_solution.iteration_count

gsimplex/solvers/simplex_interface.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Tuple
+
+from gsimplex.solvers.solver_interface import ISolver
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+
+class ISimplex(ISolver, ABC):
+    @abstractmethod
+    def get_feasible_vertex(self, problem: Problem) -> Optional[Tuple[Vertex, int]]:
+        pass
+
+    @abstractmethod
+    def make_feasible(self, vertex: Vertex) -> Optional[Vertex]:
+        pass

gsimplex/solvers/solver_interface.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from gsimplex.problem import Problem
+from gsimplex.vertex import Vertex
+from gsimplex.solution import Solution
+
+class ISolver(ABC):
+    @abstractmethod
+    def maximize(self, problem: Problem, start_basis: Optional[list[int]] = None) -> Optional[Solution]:
+        pass
+
+    def minimize(self, 
+                 problem: Problem, 
+                 start_basis: Optional[list[int]] = None
+                 ) -> Optional[Solution]:
+        
+        inverted_problem = Problem(-problem.c, problem.A, problem.b)
+        result = self.maximize(inverted_problem, start_basis)
+        if result is None:
+            return None
+        
+        # Change back to original problem
+        return Solution(
+            point=Vertex(problem, result.basis),
+            iteration_count=result.iteration_count
+        )

gsimplex/tools/extractor.py

@@ -0,0 +1,37 @@
+import bz2
+import gzip
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import BinaryIO
+
+class Extractor:
+    @staticmethod
+    def is_compressed(filepath: str|Path) -> bool:
+        path = Path(filepath)
+        return path.suffix.lower() in ['.bz2', '.gz', '.zip']
+    
+    @staticmethod
+    def extract_to_stream(filepath: str|Path) -> BinaryIO:
+        path = Path(filepath)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {path}")
+
+        suffix = path.suffix.lower()
+        
+        with open(filepath, 'rb') as f:
+            if suffix == '.bz2':
+                return BytesIO(bz2.decompress(f.read()))
+            elif suffix == '.gz':
+                return BytesIO(gzip.decompress(f.read()))
+            elif suffix == '.zip':
+                # For simplicity, assume single file in zip
+                with zipfile.ZipFile(f) as zf:
+                    names = zf.namelist()
+                    if names:
+                        return BytesIO(zf.read(names[0]))
+                    else:
+                        raise ValueError("Empty zip file")
+            
+            # Not compressed, return file stream
+            return open(filepath, 'rb')