solverpilot 0.1__py3-none-any.whl

solverpilot/backends/scipy_highs.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+
+import numpy as np
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, ObjectiveSense, QuadraticProblem, VariableDomain
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+@dataclass(slots=True)
+class ScipyHighsBackend:
+    """Development bridge to the HiGHS implementation bundled by SciPy.
+
+    This is intentionally not the final native highspy adapter. It exists to exercise
+    the backend protocol, status normalization, and end-to-end validation in environments
+    where highspy itself is unavailable.
+    """
+
+    time_limit_s: float | None = None
+    mip_rel_gap: float | None = None
+    presolve: bool | None = None
+
+    @property
+    def manifest(self) -> BackendManifest:
+        version = None
+        if self.is_available():
+            import scipy
+            version = scipy.__version__
+        return BackendManifest(
+            name="scipy-highs-bridge",
+            version=version,
+            capabilities={
+                Capability.LP: SupportLevel.NATIVE,
+                Capability.MILP: SupportLevel.NATIVE,
+                Capability.CONVEX_QP: SupportLevel.UNSUPPORTED,
+                Capability.MIP_START: SupportLevel.UNSUPPORTED,
+                Capability.BASIS_START: SupportLevel.UNSUPPORTED,
+                Capability.SAME_SPARSITY_DATA_UPDATE: SupportLevel.UNSUPPORTED,
+                Capability.STRUCTURAL_INCREMENTAL_UPDATE: SupportLevel.UNSUPPORTED,
+                Capability.NATIVE_REOPTIMIZATION: SupportLevel.UNSUPPORTED,
+                Capability.CALLBACK_PROGRESS: SupportLevel.UNSUPPORTED,
+                Capability.IIS: SupportLevel.UNSUPPORTED,
+            },
+            metadata={
+                "development_bridge": True,
+                "underlying_solver": "HiGHS via scipy.optimize.milp",
+            },
+        )
+
+    def is_available(self) -> bool:
+        return importlib.util.find_spec("scipy.optimize") is not None
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if not self.is_available():
+            raise BackendUnavailableError("SciPy optimize is not available")
+        if isinstance(problem, QuadraticProblem):
+            raise ValueError("scipy-highs-bridge does not support QuadraticProblem")
+        if not isinstance(problem, LinearProblem):
+            raise TypeError(f"unsupported problem type: {type(problem)!r}")
+
+        from scipy.optimize import Bounds, LinearConstraint, milp
+
+        c = np.array(problem.c, copy=True)
+        if problem.objective_sense is ObjectiveSense.MAXIMIZE:
+            c = -c
+
+        integrality = np.zeros(problem.n_variables, dtype=np.int32)
+        integer_mask = np.isin(
+            problem.domains,
+            [VariableDomain.INTEGER.value, VariableDomain.BINARY.value],
+        )
+        integrality[integer_mask] = 1
+
+        options: dict[str, object] = {"disp": False}
+        if self.time_limit_s is not None:
+            if self.time_limit_s <= 0:
+                raise ValueError("time_limit_s must be positive")
+            options["time_limit"] = float(self.time_limit_s)
+        if self.mip_rel_gap is not None:
+            if self.mip_rel_gap < 0:
+                raise ValueError("mip_rel_gap must be non-negative")
+            options["mip_rel_gap"] = float(self.mip_rel_gap)
+        if self.presolve is not None:
+            options["presolve"] = bool(self.presolve)
+
+        result = milp(
+            c=c,
+            integrality=integrality,
+            bounds=Bounds(problem.variable_lower, problem.variable_upper),
+            constraints=LinearConstraint(
+                problem.A,
+                problem.constraint_lower,
+                problem.constraint_upper,
+            ),
+            options=options,
+        )
+
+        status = self._status_name(int(result.status), result.x is not None)
+        x = None if result.x is None else np.asarray(result.x, dtype=np.float64)
+        objective = None
+        if x is not None:
+            objective = float(problem.c @ x + problem.objective_offset)
+
+        raw = {
+            "scipy_status": int(result.status),
+            "message": str(result.message),
+            "success": bool(result.success),
+        }
+        for attr in ("mip_node_count", "mip_dual_bound", "mip_gap"):
+            if hasattr(result, attr):
+                value = getattr(result, attr)
+                if value is not None:
+                    raw[attr] = float(value)
+
+        return BackendSolveResult(
+            backend_status=status,
+            x=x,
+            objective_reported=objective,
+            raw_statistics=raw,
+        )
+
+    @staticmethod
+    def _status_name(status: int, has_solution: bool) -> str:
+        if status == 0:
+            return "optimal"
+        if status == 1:
+            return "limit_feasible" if has_solution else "limit_no_solution"
+        if status == 2:
+            return "infeasible"
+        if status == 3:
+            return "unbounded"
+        if status == 4:
+            return "solver_error"
+        return "unknown"

solverpilot/backends/scipy_highs_lp.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+
+import numpy as np
+from scipy import sparse
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, ObjectiveSense, QuadraticProblem
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+@dataclass(slots=True)
+class ScipyHighsLPBackend:
+    """Development LP backend using ``scipy.optimize.linprog`` + HiGHS.
+
+    Parameters
+    ----------
+    method:
+        ``"highs-ds"`` for HiGHS dual simplex or ``"highs-ipm"`` for the
+        HiGHS interior-point method.  This backend intentionally supports only
+        continuous LPs; integer and quadratic models must be routed elsewhere.
+
+    Notes
+    -----
+    This is a development bridge, not the eventual native ``highspy`` adapter.
+    It exists so the adaptive runtime can exercise real algorithm alternatives
+    without pretending SciPy exposes native HiGHS state reuse.
+    """
+
+    method: str = "highs-ds"
+    time_limit_s: float | None = None
+    presolve: bool | None = None
+
+    def __post_init__(self) -> None:
+        if self.method not in {"highs-ds", "highs-ipm"}:
+            raise ValueError("method must be 'highs-ds' or 'highs-ipm'")
+        if self.time_limit_s is not None and self.time_limit_s <= 0:
+            raise ValueError("time_limit_s must be positive")
+
+    @property
+    def manifest(self) -> BackendManifest:
+        version = None
+        if self.is_available():
+            import scipy
+
+            version = scipy.__version__
+        return BackendManifest(
+            name=f"scipy-{self.method}",
+            version=version,
+            capabilities={
+                Capability.LP: SupportLevel.NATIVE,
+                Capability.MILP: SupportLevel.UNSUPPORTED,
+                Capability.CONVEX_QP: SupportLevel.UNSUPPORTED,
+                Capability.MIP_START: SupportLevel.UNSUPPORTED,
+                Capability.PRIMAL_START: SupportLevel.UNSUPPORTED,
+                Capability.DUAL_START: SupportLevel.UNSUPPORTED,
+                Capability.BASIS_START: SupportLevel.UNSUPPORTED,
+                Capability.SAME_SPARSITY_DATA_UPDATE: SupportLevel.UNSUPPORTED,
+                Capability.STRUCTURAL_INCREMENTAL_UPDATE: SupportLevel.UNSUPPORTED,
+                Capability.NATIVE_REOPTIMIZATION: SupportLevel.UNSUPPORTED,
+                Capability.CALLBACK_PROGRESS: SupportLevel.UNSUPPORTED,
+                Capability.IIS: SupportLevel.UNSUPPORTED,
+                Capability.INFEASIBILITY_CERTIFICATE: SupportLevel.UNSUPPORTED,
+            },
+            metadata={
+                "development_bridge": True,
+                "underlying_solver": f"HiGHS {self.method} via scipy.optimize.linprog",
+                "algorithm": "dual_simplex" if self.method == "highs-ds" else "interior_point",
+            },
+        )
+
+    def is_available(self) -> bool:
+        return importlib.util.find_spec("scipy.optimize") is not None
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if not self.is_available():
+            raise BackendUnavailableError("SciPy optimize is not available")
+        if isinstance(problem, QuadraticProblem):
+            raise ValueError(f"{self.manifest.name} does not support QuadraticProblem")
+        if not isinstance(problem, LinearProblem):
+            raise TypeError(f"unsupported problem type: {type(problem)!r}")
+        if problem.has_integer_variables:
+            raise ValueError(f"{self.manifest.name} supports continuous LPs only")
+
+        from scipy.optimize import linprog
+
+        c = np.array(problem.c, copy=True)
+        if problem.objective_sense is ObjectiveSense.MAXIMIZE:
+            c = -c
+
+        A_ub, b_ub, A_eq, b_eq = _to_linprog_constraints(problem)
+        bounds = list(zip(problem.variable_lower.tolist(), problem.variable_upper.tolist()))
+
+        options: dict[str, object] = {"disp": False}
+        if self.time_limit_s is not None:
+            options["time_limit"] = float(self.time_limit_s)
+        if self.presolve is not None:
+            options["presolve"] = bool(self.presolve)
+
+        result = linprog(
+            c,
+            A_ub=A_ub,
+            b_ub=b_ub,
+            A_eq=A_eq,
+            b_eq=b_eq,
+            bounds=bounds,
+            method=self.method,
+            options=options,
+        )
+
+        status = self._status_name(int(result.status), result.x is not None)
+        x = None if result.x is None else np.asarray(result.x, dtype=np.float64)
+        objective = None
+        if x is not None:
+            objective = float(problem.c @ x + problem.objective_offset)
+
+        raw: dict[str, object] = {
+            "scipy_status": int(result.status),
+            "message": str(result.message),
+            "success": bool(result.success),
+            "nit": int(getattr(result, "nit", 0) or 0),
+            "method": self.method,
+        }
+        if hasattr(result, "crossover_nit") and result.crossover_nit is not None:
+            raw["crossover_nit"] = int(result.crossover_nit)
+
+        return BackendSolveResult(
+            backend_status=status,
+            x=x,
+            objective_reported=objective,
+            raw_statistics=raw,
+        )
+
+    @staticmethod
+    def _status_name(status: int, has_solution: bool) -> str:
+        if status == 0:
+            return "optimal"
+        if status == 1:
+            return "limit_feasible" if has_solution else "limit_no_solution"
+        if status == 2:
+            return "infeasible"
+        if status == 3:
+            return "unbounded"
+        if status == 4:
+            return "solver_error"
+        return "unknown"
+
+
+def _to_linprog_constraints(
+    problem: LinearProblem,
+) -> tuple[
+    sparse.csr_matrix | None,
+    np.ndarray | None,
+    sparse.csr_matrix | None,
+    np.ndarray | None,
+]:
+    """Translate ranged rows into linprog equality/upper-bound form.
+
+    A row ``l <= a @ x <= u`` becomes:
+    - equality if finite ``l == u``;
+    - ``a @ x <= u`` when ``u`` is finite;
+    - ``-a @ x <= -l`` when ``l`` is finite.
+
+    The canonical problem remains the source of truth for final validation.
+    """
+
+    ub_rows: list[sparse.csr_matrix] = []
+    ub_rhs: list[float] = []
+    eq_rows: list[sparse.csr_matrix] = []
+    eq_rhs: list[float] = []
+
+    for i in range(problem.n_constraints):
+        lo = float(problem.constraint_lower[i])
+        hi = float(problem.constraint_upper[i])
+        row = problem.A.getrow(i)
+
+        if np.isfinite(lo) and np.isfinite(hi) and lo == hi:
+            eq_rows.append(row)
+            eq_rhs.append(lo)
+            continue
+        if np.isfinite(hi):
+            ub_rows.append(row)
+            ub_rhs.append(hi)
+        if np.isfinite(lo):
+            ub_rows.append(-row)
+            ub_rhs.append(-lo)
+
+    A_ub = sparse.vstack(ub_rows, format="csr") if ub_rows else None
+    b_ub = np.asarray(ub_rhs, dtype=np.float64) if ub_rows else None
+    A_eq = sparse.vstack(eq_rows, format="csr") if eq_rows else None
+    b_eq = np.asarray(eq_rhs, dtype=np.float64) if eq_rows else None
+    return A_ub, b_ub, A_eq, b_eq

solverpilot/backends/scipy_slsqp_qp.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+
+import numpy as np
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, QuadraticProblem
+from solverpilot.problem.quadratic import require_confirmed_convexity
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+@dataclass(slots=True)
+class ScipySLSQPQPBackend:
+    """Small-problem development bridge for convex QP via SciPy SLSQP.
+
+    This backend exists only to exercise the full QP runtime path when OSQP is not
+    installed. It deliberately advertises ``EMULATED_SAFE`` rather than native QP
+    support and does not claim an optimality certificate. A successful SLSQP exit
+    is normalized as a validated feasible candidate by the runtime.
+    """
+
+    maxiter: int = 1000
+    ftol: float = 1e-10
+
+    def __post_init__(self) -> None:
+        if self.maxiter <= 0:
+            raise ValueError("maxiter must be positive")
+        if self.ftol <= 0:
+            raise ValueError("ftol must be positive")
+
+    @property
+    def manifest(self) -> BackendManifest:
+        version = None
+        if self.is_available():
+            import scipy
+
+            version = scipy.__version__
+        return BackendManifest(
+            name="scipy-slsqp-qp-bridge",
+            version=version,
+            capabilities={
+                Capability.LP: SupportLevel.UNSUPPORTED,
+                Capability.MILP: SupportLevel.UNSUPPORTED,
+                Capability.CONVEX_QP: SupportLevel.EMULATED_SAFE,
+                Capability.PRIMAL_START: SupportLevel.UNSUPPORTED,
+                Capability.DUAL_START: SupportLevel.UNSUPPORTED,
+                Capability.SAME_SPARSITY_DATA_UPDATE: SupportLevel.UNSUPPORTED,
+                Capability.NATIVE_REOPTIMIZATION: SupportLevel.UNSUPPORTED,
+                Capability.INFEASIBILITY_CERTIFICATE: SupportLevel.UNSUPPORTED,
+            },
+            metadata={
+                "development_bridge": True,
+                "underlying_solver": "scipy.optimize.minimize(method='SLSQP')",
+                "no_optimality_certificate": True,
+            },
+        )
+
+    def is_available(self) -> bool:
+        return importlib.util.find_spec("scipy.optimize") is not None
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if not self.is_available():
+            raise BackendUnavailableError("SciPy optimize is not available")
+        if not isinstance(problem, QuadraticProblem):
+            raise ValueError("scipy-slsqp-qp-bridge supports QuadraticProblem only")
+
+        from scipy.optimize import Bounds, LinearConstraint, minimize
+
+        linear = problem.linear
+        P = ((problem.P + problem.P.T) * 0.5).tocsr()
+        q = linear.c
+
+        def fun(x: np.ndarray) -> float:
+            return float(0.5 * x @ (P @ x) + q @ x + linear.objective_offset)
+
+        def jac(x: np.ndarray) -> np.ndarray:
+            return np.asarray(P @ x + q, dtype=np.float64)
+
+        x0 = _initial_point(linear.variable_lower, linear.variable_upper)
+        constraints = []
+        if linear.n_constraints:
+            constraints = [
+                LinearConstraint(
+                    linear.A,
+                    linear.constraint_lower,
+                    linear.constraint_upper,
+                )
+            ]
+        result = minimize(
+            fun,
+            x0,
+            jac=jac,
+            method="SLSQP",
+            bounds=Bounds(linear.variable_lower, linear.variable_upper),
+            constraints=constraints,
+            options={
+                "disp": False,
+                "maxiter": int(self.maxiter),
+                "ftol": float(self.ftol),
+            },
+        )
+
+        x = None if result.x is None else np.asarray(result.x, dtype=np.float64)
+        status = "converged_candidate" if bool(result.success) else (
+            "limit_feasible" if x is not None else "solver_error"
+        )
+        objective = None if x is None else fun(x)
+        return BackendSolveResult(
+            backend_status=status,
+            x=x,
+            objective_reported=objective,
+            raw_statistics={
+                "scipy_status": int(result.status),
+                "message": str(result.message),
+                "success": bool(result.success),
+                "nit": int(getattr(result, "nit", 0) or 0),
+                "development_only": True,
+            },
+        )
+
+
+def _initial_point(lower: np.ndarray, upper: np.ndarray) -> np.ndarray:
+    x = np.zeros_like(lower, dtype=np.float64)
+    both = np.isfinite(lower) & np.isfinite(upper)
+    x[both] = 0.5 * (lower[both] + upper[both])
+    only_lower = np.isfinite(lower) & ~np.isfinite(upper)
+    x[only_lower] = np.maximum(0.0, lower[only_lower])
+    only_upper = ~np.isfinite(lower) & np.isfinite(upper)
+    x[only_upper] = np.minimum(0.0, upper[only_upper])
+    return x