solverpilot 0.1__py3-none-any.whl

solverpilot/backends/highspy_native.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+from importlib.metadata import PackageNotFoundError, version
+
+import numpy as np
+from scipy import sparse
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, ObjectiveSense, QuadraticProblem, VariableDomain
+from solverpilot.problem.quadratic import require_confirmed_convexity
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+def _highs_status_from_strings(model_status: str, primal_status: str) -> str:
+    model = model_status.strip().lower()
+    primal_feasible = "feasible" in primal_status.strip().lower() and "infeasible" not in primal_status.strip().lower()
+    if "optimal" in model:
+        return "optimal"
+    if "unbounded or infeasible" in model or "infeasible or unbounded" in model:
+        return "infeasible_or_unbounded"
+    if "infeasible" in model:
+        return "infeasible"
+    if "unbounded" in model:
+        return "unbounded"
+    if any(token in model for token in ("time limit", "iteration limit", "solution limit", "objective bound", "objective target", "interrupt")):
+        return "limit_feasible" if primal_feasible else "limit_no_solution"
+    if any(token in model for token in ("model error", "solve error", "memory limit")):
+        return "solver_error"
+    return "unknown"
+
+
+def _linear_csc(problem: LinearProblem) -> sparse.csc_matrix:
+    A = problem.A.tocsc(copy=True)
+    A.sort_indices()
+    return A
+
+
+def _lower_hessian_csc(problem: QuadraticProblem) -> sparse.csc_matrix:
+    P = sparse.tril(problem.P, format="csc")
+    P.sort_indices()
+    return P
+
+
+@dataclass(slots=True)
+class HighspyNativeBackend:
+    """Optional native HiGHS backend.
+
+    This adapter is import-safe in environments without ``highspy``. M2 implements
+    native LP/MILP/QP model construction and result normalization. Stateful basis and
+    MIP-start reuse are intentionally not claimed until they can be integration-tested.
+    """
+
+    time_limit_s: float | None = None
+    threads: int | None = None
+    presolve: bool | None = None
+    solver: str | None = None
+
+    @property
+    def manifest(self) -> BackendManifest:
+        pkg_version = None
+        if self.is_available():
+            try:
+                pkg_version = version("highspy")
+            except PackageNotFoundError:
+                pass
+        return BackendManifest(
+            name="highspy-native",
+            version=pkg_version,
+            capabilities={
+                Capability.LP: SupportLevel.NATIVE,
+                Capability.CONVEX_QP: SupportLevel.NATIVE,
+                Capability.MILP: SupportLevel.NATIVE,
+                # Upstream supports these mechanisms, but M2 adapter does not yet apply them.
+                Capability.MIP_START: SupportLevel.UNKNOWN,
+                Capability.PRIMAL_START: SupportLevel.UNKNOWN,
+                Capability.DUAL_START: SupportLevel.UNKNOWN,
+                Capability.BASIS_START: SupportLevel.UNKNOWN,
+                Capability.SAME_SPARSITY_DATA_UPDATE: SupportLevel.UNKNOWN,
+                Capability.STRUCTURAL_INCREMENTAL_UPDATE: SupportLevel.UNKNOWN,
+                Capability.NATIVE_REOPTIMIZATION: SupportLevel.UNSUPPORTED,
+                Capability.CALLBACK_PROGRESS: SupportLevel.UNKNOWN,
+                Capability.IIS: SupportLevel.UNKNOWN,
+                Capability.INFEASIBILITY_CERTIFICATE: SupportLevel.UNKNOWN,
+            },
+            metadata={
+                "native_adapter": True,
+                "stateful": False,
+                "reuse_claim": "none in M2 adapter",
+            },
+        )
+
+    def is_available(self) -> bool:
+        if importlib.util.find_spec("highspy") is None:
+            return False
+        try:
+            # Finding package metadata is insufficient: the extension may not
+            # load, or another HiGHS ABI may already occupy its library name.
+            # Resolve the dedicated native adapter before verification bridges
+            # are examined by the default registry.
+            importlib.import_module("highspy")
+        except (ImportError, OSError):
+            return False
+        return True
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if not self.is_available():
+            raise BackendUnavailableError("highspy is not installed")
+        import highspy
+
+        h = highspy.Highs()
+        h.setOptionValue("output_flag", False)
+        if self.time_limit_s is not None:
+            if self.time_limit_s <= 0:
+                raise ValueError("time_limit_s must be positive")
+            h.setOptionValue("time_limit", float(self.time_limit_s))
+        if self.threads is not None:
+            if self.threads <= 0:
+                raise ValueError("threads must be positive")
+            h.setOptionValue("threads", int(self.threads))
+        if self.presolve is not None:
+            h.setOptionValue("presolve", "on" if self.presolve else "off")
+        if self.solver is not None:
+            h.setOptionValue("solver", str(self.solver))
+
+        if isinstance(problem, QuadraticProblem):
+            require_confirmed_convexity(problem)
+            model = self._make_qp_model(highspy, problem)
+        elif isinstance(problem, LinearProblem):
+            model = self._make_lp_model(highspy, problem)
+        else:
+            raise TypeError(f"unsupported problem type: {type(problem)!r}")
+
+        pass_status = h.passModel(model)
+        if "error" in str(pass_status).lower():
+            raise RuntimeError(f"HiGHS rejected model: {pass_status}")
+        h.run()
+        info = h.getInfo()
+        model_status = h.modelStatusToString(h.getModelStatus())
+        primal_status = h.solutionStatusToString(info.primal_solution_status)
+        backend_status = _highs_status_from_strings(model_status, primal_status)
+
+        x = None
+        if backend_status in {"optimal", "limit_feasible"}:
+            solution = h.getSolution()
+            x_candidate = np.asarray(list(solution.col_value), dtype=np.float64)
+            if x_candidate.shape == (problem.n_variables,) and np.all(np.isfinite(x_candidate)):
+                x = x_candidate
+
+        objective = None
+        objective_internal = None
+        if x is not None:
+            try:
+                candidate = float(h.getObjectiveValue())
+                if np.isfinite(candidate):
+                    objective_internal = candidate
+                    objective = candidate
+            except Exception:
+                objective_internal = None
+
+        raw = {
+            "model_status": str(model_status),
+            "primal_solution_status": str(primal_status),
+            "simplex_iteration_count": int(getattr(info, "simplex_iteration_count", 0)),
+            "ipm_iteration_count": int(getattr(info, "ipm_iteration_count", 0)),
+            "qp_iteration_count": int(getattr(info, "qp_iteration_count", 0)),
+            "mip_node_count": int(getattr(info, "mip_node_count", 0)),
+            "reuse_applied": False,
+            "reuse_mode": "cold_native_solve",
+            "objective_internal": objective_internal,
+        }
+        return BackendSolveResult(
+            backend_status=backend_status,
+            x=x,
+            objective_reported=objective,
+            raw_statistics=raw,
+        )
+
+    @staticmethod
+    def _make_lp_model(highspy, problem: LinearProblem):
+        lp = highspy.HighsLp()
+        lp.num_col_ = problem.n_variables
+        lp.num_row_ = problem.n_constraints
+        lp.col_cost_ = np.asarray(problem.c, dtype=np.float64)
+        lp.col_lower_ = np.asarray(problem.variable_lower, dtype=np.float64)
+        lp.col_upper_ = np.asarray(problem.variable_upper, dtype=np.float64)
+        lp.row_lower_ = np.asarray(problem.constraint_lower, dtype=np.float64)
+        lp.row_upper_ = np.asarray(problem.constraint_upper, dtype=np.float64)
+        lp.sense_ = highspy.ObjSense.kMinimize if problem.objective_sense is ObjectiveSense.MINIMIZE else highspy.ObjSense.kMaximize
+        lp.offset_ = float(problem.objective_offset)
+        A = _linear_csc(problem)
+        lp.a_matrix_.format_ = highspy.MatrixFormat.kColwise
+        lp.a_matrix_.start_ = np.asarray(A.indptr, dtype=np.int64)
+        lp.a_matrix_.index_ = np.asarray(A.indices, dtype=np.int32)
+        lp.a_matrix_.value_ = np.asarray(A.data, dtype=np.float64)
+        if problem.has_integer_variables:
+            lp.integrality_ = [
+                highspy.HighsVarType.kInteger
+                if domain in {VariableDomain.INTEGER.value, VariableDomain.BINARY.value}
+                else highspy.HighsVarType.kContinuous
+                for domain in problem.domains
+            ]
+        return lp
+
+    @classmethod
+    def _make_qp_model(cls, highspy, problem: QuadraticProblem):
+        model = highspy.HighsModel()
+        model.lp_ = cls._make_lp_model(highspy, problem.linear)
+        P = _lower_hessian_csc(problem)
+        model.hessian_.dim_ = problem.n_variables
+        model.hessian_.format_ = highspy.HessianFormat.kTriangular
+        model.hessian_.start_ = np.asarray(P.indptr, dtype=np.int64)
+        model.hessian_.index_ = np.asarray(P.indices, dtype=np.int32)
+        model.hessian_.value_ = np.asarray(P.data, dtype=np.float64)
+        return model

solverpilot/backends/nlopt_native.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+from importlib.metadata import PackageNotFoundError, version
+
+import numpy as np
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, ObjectiveSense, QuadraticProblem
+from solverpilot.problem.quadratic import require_confirmed_convexity
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+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 np.minimum(np.maximum(x, lower), upper)
+
+
+def _nlopt_status(code: int, *, has_candidate: bool) -> str:
+    # NLopt positive result codes indicate a successful stop criterion, but not a
+    # mathematical optimality certificate. Preserve that distinction.
+    if code in {1, 2, 3, 4}:
+        return "converged_candidate" if has_candidate else "solver_error"
+    if code in {5, 6}:  # max evaluations / max time
+        return "limit_feasible" if has_candidate else "limit_no_solution"
+    if code in {-4, -5}:  # roundoff-limited / forced stop
+        return "limit_feasible" if has_candidate else "limit_no_solution"
+    return "solver_error"
+
+
+@dataclass(slots=True)
+class NLoptNativeBackend:
+    """Optional cross-library continuous optimizer backend using NLopt SLSQP.
+
+    This adapter is deliberately conservative: it accepts continuous LP and convex
+    QP instances but never claims a proof of optimality. A positive NLopt stop is
+    normalized as a candidate and SolverPilot's independent validator remains the
+    authority on feasibility.
+    """
+
+    time_limit_s: float | None = None
+    max_evals: int = 2000
+    ftol_rel: float = 1e-10
+    xtol_rel: float = 1e-10
+    constraint_tol: float = 1e-8
+
+    def __post_init__(self) -> None:
+        if self.time_limit_s is not None and self.time_limit_s <= 0:
+            raise ValueError("time_limit_s must be positive")
+        if self.max_evals <= 0:
+            raise ValueError("max_evals must be positive")
+        if self.ftol_rel <= 0 or self.xtol_rel <= 0 or self.constraint_tol < 0:
+            raise ValueError("NLopt tolerances must be positive (constraint_tol may be zero)")
+
+    @property
+    def manifest(self) -> BackendManifest:
+        pkg_version = None
+        if self.is_available():
+            try:
+                pkg_version = version("nlopt")
+            except PackageNotFoundError:
+                try:
+                    import nlopt
+                    pkg_version = getattr(nlopt, "__version__", None)
+                except Exception:
+                    pass
+        return BackendManifest(
+            name="nlopt-slsqp-native",
+            version=pkg_version,
+            capabilities={
+                Capability.LP: SupportLevel.EMULATED_SAFE,
+                Capability.CONVEX_QP: SupportLevel.EMULATED_SAFE,
+                Capability.MILP: 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={
+                "native_adapter": True,
+                "underlying_solver": "NLopt LD_SLSQP",
+                "continuous_only": True,
+                "no_optimality_certificate": True,
+                "cross_library_backend": True,
+            },
+        )
+
+    def is_available(self) -> bool:
+        return importlib.util.find_spec("nlopt") is not None
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if not self.is_available():
+            raise BackendUnavailableError("nlopt is not installed")
+        import nlopt
+
+        if isinstance(problem, QuadraticProblem):
+            require_confirmed_convexity(problem)
+            linear = problem.linear
+            P = ((problem.P + problem.P.T) * 0.5).tocsr()
+        elif isinstance(problem, LinearProblem):
+            if problem.has_integer_variables:
+                raise ValueError("NLopt backend supports continuous LP only")
+            linear = problem
+            P = None
+        else:
+            raise TypeError(f"unsupported problem type: {type(problem)!r}")
+
+        n = linear.n_variables
+        opt = nlopt.opt(nlopt.LD_SLSQP, n)
+        opt.set_lower_bounds(np.asarray(linear.variable_lower, dtype=np.float64))
+        opt.set_upper_bounds(np.asarray(linear.variable_upper, dtype=np.float64))
+        opt.set_maxeval(int(self.max_evals))
+        opt.set_ftol_rel(float(self.ftol_rel))
+        opt.set_xtol_rel(float(self.xtol_rel))
+        if self.time_limit_s is not None:
+            opt.set_maxtime(float(self.time_limit_s))
+
+        if P is None:
+            c = np.asarray(linear.c, dtype=np.float64)
+
+            def objective(x, grad):
+                if grad.size:
+                    grad[:] = c
+                return float(c @ x + linear.objective_offset)
+        else:
+            q = np.asarray(linear.c, dtype=np.float64)
+
+            def objective(x, grad):
+                px = np.asarray(P @ x, dtype=np.float64)
+                if grad.size:
+                    grad[:] = px + q
+                return float(0.5 * x @ px + q @ x + linear.objective_offset)
+
+        if linear.objective_sense is ObjectiveSense.MAXIMIZE:
+            if P is not None:
+                raise ValueError("convex QuadraticProblem only supports minimization")
+            opt.set_max_objective(objective)
+        else:
+            opt.set_min_objective(objective)
+
+        A = linear.A.tocsr()
+        tol = float(self.constraint_tol)
+        callbacks = []  # keep closures alive for the lifetime of optimize()
+        for i in range(linear.n_constraints):
+            start, end = A.indptr[i], A.indptr[i + 1]
+            indices = np.asarray(A.indices[start:end], dtype=np.int64).copy()
+            values = np.asarray(A.data[start:end], dtype=np.float64).copy()
+            lo = float(linear.constraint_lower[i])
+            hi = float(linear.constraint_upper[i])
+
+            def row_value(x, indices=indices, values=values):
+                return float(values @ x[indices]) if values.size else 0.0
+
+            if np.isfinite(lo) and np.isfinite(hi) and np.isclose(lo, hi, rtol=0.0, atol=0.0):
+                rhs = hi
+
+                def eq(x, grad, indices=indices, values=values, rhs=rhs):
+                    if grad.size:
+                        grad[:] = 0.0
+                        grad[indices] = values
+                    return float((values @ x[indices] if values.size else 0.0) - rhs)
+
+                callbacks.append(eq)
+                opt.add_equality_constraint(eq, tol)
+                continue
+
+            if np.isfinite(hi):
+                rhs = hi
+
+                def upper(x, grad, indices=indices, values=values, rhs=rhs):
+                    if grad.size:
+                        grad[:] = 0.0
+                        grad[indices] = values
+                    return float((values @ x[indices] if values.size else 0.0) - rhs)
+
+                callbacks.append(upper)
+                opt.add_inequality_constraint(upper, tol)
+
+            if np.isfinite(lo):
+                rhs = lo
+
+                def lower(x, grad, indices=indices, values=values, rhs=rhs):
+                    if grad.size:
+                        grad[:] = 0.0
+                        grad[indices] = -values
+                    return float(rhs - (values @ x[indices] if values.size else 0.0))
+
+                callbacks.append(lower)
+                opt.add_inequality_constraint(lower, tol)
+
+        x0 = _initial_point(linear.variable_lower, linear.variable_upper)
+        x = None
+        objective_reported = None
+        code = None
+        error = None
+        try:
+            candidate = np.asarray(opt.optimize(x0), dtype=np.float64)
+            code = int(opt.last_optimize_result())
+            if candidate.shape == (n,) and np.all(np.isfinite(candidate)):
+                x = candidate
+                objective_reported = float(opt.last_optimum_value())
+        except Exception as exc:
+            # NLopt exceptions may still leave a meaningful candidate unavailable to Python;
+            # do not manufacture one. Preserve the exception in raw statistics.
+            try:
+                code = int(opt.last_optimize_result())
+            except Exception:
+                code = None
+            error = f"{type(exc).__name__}: {exc}"
+
+        backend_status = _nlopt_status(-1 if code is None else code, has_candidate=x is not None)
+        return BackendSolveResult(
+            backend_status=backend_status,
+            x=x,
+            objective_reported=objective_reported,
+            raw_statistics={
+                "nlopt_result_code": code,
+                "algorithm": "LD_SLSQP",
+                "error": error,
+                "reuse_applied": False,
+                "reuse_mode": "cold_native_solve",
+                "no_optimality_certificate": True,
+            },
+        )