primalsolver 0.1.1__py3-none-win_amd64.whl

primalsolver/__init__.py

@@ -0,0 +1,373 @@
+"""PrimalSolver from Python — a thin, convenience wrapper over the C99 library.
+
+    from primalsolver import Model, BK, SOL_ITR
+
+    with Model(maxcon=2, maxvar=2) as m:
+        m.obj([0, 1], [-3.0, -2.0])
+        m.a_ij(0, 0, 1.0); m.a_ij(0, 1, 1.0)   # x0 + x1 <= 4
+        m.a_ij(1, 0, 1.0); m.a_ij(1, 1, 3.0)   # x0 + 3x1 <= 6
+        m.con_bounds(0, BK.UP, up=4.0)
+        m.con_bounds(1, BK.UP, up=6.0)
+        m.var_bounds(0, BK.RA, 0.0, 3.0)
+        m.var_bounds(1, BK.RA, 0.0, 3.0)
+        r = m.solve()
+    print(r.x, r.objective, r.solsta)          # [3.0, 1.0] -11.0 1
+"""
+
+from __future__ import annotations
+
+import ctypes as C
+import types
+from collections import namedtuple
+
+from . import _native as _n
+
+__version__ = "0.1.1"
+
+LIB = _n.LIB
+c_void_p = C.c_void_p
+byref = C.byref
+
+# The full generated binding is re-exported at package level:
+#   primalsolver.PRIMAL_optimize(...), primalsolver.FUNCTIONS, primalsolver.MISSING
+FUNCTIONS = _n.FUNCTIONS
+MISSING = _n.MISSING
+globals().update(FUNCTIONS)
+
+
+class SolverError(RuntimeError):
+    """A PrimalSolver call returned a non-OK resource code (or a wrapper bug)."""
+
+
+# --- enums, numbered as the C header (and as the vendor reference) -----------
+class BK:
+    LO, UP, FX, FR, RA = 0, 1, 2, 3, 4   # PRIMALboundkeye
+
+
+class SENSE:
+    MIN, MAX = 0, 1                      # PRIMALobjsensee
+
+
+class CT:
+    QUAD, RQUAD, PEXP, DEXP, PPOW, RPOW = 0, 1, 2, 3, 4, 7   # PRIMALconetypee
+
+
+class VAR_TYPE:
+    CONT, INT, INT_BIN, SEMI_CONT, SEMI_INT = 0, 1, 2, 3, 4   # PRIMALvariabletypee
+
+
+class SK:                                  # PRIMALstakeye (basis status)
+    LOW, UPR, FIX, BAS, SUP, UNDEF = 0, 1, 2, 3, 4, 5
+
+
+class APPROX:                              # PRIMALdomaintypee (linear domains)
+    R, RZERO, RPLUS, RMINUS = 0, 1, 2, 3
+
+
+class SOL:
+    ITR, BAS, ITG = 0, 1, 2              # PRIMALsolt
+
+
+class SOLSTA:
+    UNKNOWN = 0
+    OPTIMAL = 1
+    PRIM_FEAS = 2
+    PRIM_INFEAS_CER = 5
+    DUAL_INFEAS_CER = 6
+    INTEGER_OPTIMAL = 9
+
+
+SOL_ITR = SOL.ITR
+
+Result = namedtuple("Result", "x y objective dual solsta prosta pinf rc")
+
+
+def version() -> tuple[int, int, int]:
+    a, b, c = (C.c_int(), C.c_int(), C.c_int())
+    _n.getversion(byref(a), byref(b), byref(c))
+    return a.value, b.value, c.value
+
+
+class Model:
+    """A task builder + solver. Use as a context manager to free the C handles."""
+
+    def __init__(self, maxcon: int = 0, maxvar: int = 0):
+        self.env = c_void_p()
+        self.task = c_void_p()
+        self._check(_n.makeenv(byref(self.env), None), "makeenv")
+        self._check(_n.maketask(self.env, int(maxcon), int(maxvar), byref(self.task)), "maketask")
+
+    # -- helpers -------------------------------------------------------------
+    @staticmethod
+    def _check(rc: int, what: str = "") -> None:
+        if rc != 0:
+            raise SolverError(f"PRIMAL {what} failed (rc={rc})")
+
+    @staticmethod
+    def _ivec(seq):
+        return (C.c_int * len(seq))(*seq)
+
+    @staticmethod
+    def _dvec(seq):
+        return (C.c_double * len(seq))(*[float(v) for v in seq])
+
+    def _numcon(self) -> int:
+        n = C.c_int(); self._check(_n.getnumcon(self.task, byref(n))); return n.value
+
+    def _numvar(self) -> int:
+        n = C.c_int(); self._check(_n.getnumvar(self.task, byref(n))); return n.value
+
+    # -- model building ------------------------------------------------------
+    def add_cons(self, n: int) -> None:
+        self._check(_n.appendcons(self.task, int(n)), "appendcons")
+
+    def add_vars(self, n: int) -> None:
+        self._check(_n.appendvars(self.task, int(n)), "appendvars")
+
+    def obj(self, idx, vals) -> None:
+        """Set objective coefficients c[idx] = vals (replaces those entries)."""
+        idx = list(idx); vals = list(vals)
+        self._check(_n.putclist(self.task, len(idx), self._ivec(idx), self._dvec(vals)), "putclist")
+
+    def a_ij(self, i: int, j: int, value: float) -> None:
+        self._check(_n.putaij(self.task, int(i), int(j), float(value)), "putaij")
+
+    def a_row(self, i: int, cols, vals) -> None:
+        """Replace row i with the sparse coefficients (cols, vals)."""
+        cols = list(cols); vals = list(vals)
+        self._check(_n.putarow(self.task, int(i), len(cols), self._ivec(cols), self._dvec(vals)), "putarow")
+
+    def cj(self, j: int, value: float) -> None:
+        """Set a single objective coefficient."""
+        self._check(_n.putcj(self.task, int(j), float(value)), "putcj")
+
+    def qobj(self, terms) -> None:
+        """Set the quadratic objective from (i, j, value) terms (upper triangle)."""
+        terms = list(terms)
+        qi = self._ivec([int(t[0]) for t in terms])
+        qj = self._ivec([int(t[1]) for t in terms])
+        qv = self._dvec([float(t[2]) for t in terms])
+        self._check(_n.putqobj(self.task, len(terms), qi, qj, qv), "putqobj")
+
+    def cone(self, ctype: int, members, param: float = 0.0) -> None:
+        """Append a cone whose members are the given variable indices."""
+        members = list(members)
+        self._check(_n.appendcone(self.task, int(ctype), float(param), len(members), self._ivec(members)), "appendcone")
+
+    def a_col(self, j: int, rows, vals) -> None:
+        rows = list(rows); vals = list(vals)
+        self._check(_n.putacol(self.task, int(j), len(rows), self._ivec(rows), self._dvec(vals)), "putacol")
+
+    def qconk(self, k: int, terms) -> None:
+        """Quadratic terms of constraint k: iterable of (i, j, value), i<=j."""
+        terms = list(terms)
+        self._check(_n.putqconk(self.task, int(k), len(terms),
+                                self._ivec([int(t[0]) for t in terms]),
+                                self._ivec([int(t[1]) for t in terms]),
+                                self._dvec([float(t[2]) for t in terms])), "putqconk")
+
+    def qobj_ij(self, i: int, j: int, value: float) -> None:
+        self._check(_n.putqobjij(self.task, int(i), int(j), float(value)), "putqobjij")
+
+    def var_type(self, j: int, vt: int) -> None:
+        self._check(_n.putvartype(self.task, int(j), int(vt)), "putvartype")
+
+    def var_types(self, cols, types) -> None:
+        types = list(types)
+        self._check(_n.putvartypelist(self.task, len(cols), self._ivec(list(cols)),
+                                      (C.c_int * len(types))(*types)), "putvartypelist")
+
+    def cfix(self, value: float) -> None:
+        self._check(_n.putcfix(self.task, float(value)), "putcfix")
+
+    def int_param(self, param: int, value: int) -> None:
+        self._check(_n.putintparam(self.task, int(param), int(value)), "putintparam")
+
+    def dou_param(self, param: int, value: float) -> None:
+        self._check(_n.putdouparam(self.task, int(param), float(value)), "putdouparam")
+
+    def warm_start(self, x=None, y=None) -> None:
+        if x is not None:
+            self._check(_n.putxx(self.task, SOL.ITR, self._dvec(list(x))), "putxx")
+        if y is not None:
+            self._check(_n.puty(self.task, SOL.ITR, self._dvec(list(y))), "puty")
+
+    def sos(self, kind: int, members, weights=None) -> None:
+        members = list(members)
+        w = self._dvec(list(weights) if weights is not None else [1.0] * len(members))
+        fn = _n.PRIMAL_appendsos1 if int(kind) == 1 else _n.PRIMAL_appendsos2
+        self._check(fn(self.task, len(members), self._ivec(members), w), "appendsos")
+
+    # -- SDP (semi-definite bar variables) -----------------------------------
+    def barvars(self, dims) -> None:
+        dims = list(dims)
+        self._check(_n.appendbarvars(self.task, len(dims), self._ivec(dims)), "appendbarvars")
+
+    def sparsesymmat(self, dim: int, terms) -> int:
+        """Store a sparse symmetric matrix; returns its id (for baraij/barcj)."""
+        terms = list(terms)
+        idx = C.c_int()
+        self._check(_n.appendsparsesymmat(self.task, int(dim), len(terms),
+                    self._ivec([int(t[0]) for t in terms]),
+                    self._ivec([int(t[1]) for t in terms]),
+                    self._dvec([float(t[2]) for t in terms]), byref(idx)), "appendsparsesymmat")
+        return idx.value
+
+    def baraij(self, i: int, j: int, terms) -> None:
+        terms = list(terms)               # (symmat_id, coefficient)
+        self._check(_n.putbaraij(self.task, int(i), int(j), len(terms),
+                    self._ivec([int(t[0]) for t in terms]),
+                    self._dvec([float(t[1]) for t in terms])), "putbaraij")
+
+    def barcj(self, j: int, terms) -> None:
+        terms = list(terms)
+        self._check(_n.putbarcj(self.task, int(j), len(terms),
+                    self._ivec([int(t[0]) for t in terms]),
+                    self._dvec([float(t[1]) for t in terms])), "putbarcj")
+
+    # -- affine expressions / conic + disjunctive constraints ----------------
+    def afes(self, num: int) -> None:
+        self._check(_n.appendafes(self.task, int(num)), "appendafes")
+
+    def afe_entry(self, i: int, j: int, value: float) -> None:
+        self._check(_n.putafefentry(self.task, int(i), int(j), float(value)), "putafefentry")
+
+    def afe_g(self, i: int, value: float) -> None:
+        self._check(_n.putafeg(self.task, int(i), float(value)), "putafeg")
+
+    def domain(self, kind: int, n: int = 1) -> int:
+        fn = {0: _n.PRIMAL_appendrdomain, 1: _n.PRIMAL_appendrzerodomain,
+              2: _n.PRIMAL_appendrplusdomain, 3: _n.PRIMAL_appendrminusdomain}[int(kind)]
+        idx = C.c_longlong()
+        self._check(fn(self.task, int(n), byref(idx)), "appenddomain")
+        return idx.value
+
+    def acc(self, domidx: int, afeidx, b=None) -> None:
+        afeidx = list(afeidx)
+        bb = self._dvec(list(b) if b is not None else [0.0] * len(afeidx))
+        a64 = (C.c_longlong * len(afeidx))(*[int(a) for a in afeidx])
+        self._check(_n.appendacc(self.task, int(domidx), len(afeidx), a64, bb), "appendacc")
+
+    def djcs(self, num: int) -> None:
+        self._check(_n.appenddjcs(self.task, int(num)), "appenddjcs")
+
+    def djc(self, idx: int, domidxlist, afeidxlist, b, termsizelist) -> None:
+        dom = (C.c_longlong * len(domidxlist))(*[int(d) for d in domidxlist])
+        afe = (C.c_longlong * len(afeidxlist))(*[int(a) for a in afeidxlist])
+        bv = self._dvec(list(b))
+        ts = (C.c_longlong * len(termsizelist))(*[int(t) for t in termsizelist])
+        self._check(_n.putdjc(self.task, int(idx), len(domidxlist), dom,
+                    len(afeidxlist), afe, bv, len(termsizelist), ts), "putdjc")
+
+    # -- data getters (for independent verification) -------------------------
+    def getcj(self, j: int) -> float:
+        v = C.c_double(); self._check(_n.getcj(self.task, int(j), byref(v))); return v.value
+
+    def getaij(self, i: int, j: int) -> float:
+        v = C.c_double(); self._check(_n.getaij(self.task, int(i), int(j), byref(v))); return v.value
+
+    def getvarbound(self, j: int):
+        bk = C.c_int(); bl = C.c_double(); bu = C.c_double()
+        self._check(_n.getvarbound(self.task, int(j), byref(bk), byref(bl), byref(bu)))
+        return bk.value, bl.value, bu.value
+
+    def getconbound(self, i: int):
+        bk = C.c_int(); bl = C.c_double(); bu = C.c_double()
+        self._check(_n.getconbound(self.task, int(i), byref(bk), byref(bl), byref(bu)))
+        return bk.value, bl.value, bu.value
+
+    def getcfix(self) -> float:
+        v = C.c_double(); self._check(_n.getcfix(self.task, byref(v))); return v.value
+
+    def getdualinfeas(self) -> float:
+        v = C.c_double(); self._check(_n.getdualinfeas(self.task, SOL.ITR, byref(v))); return v.value
+
+    def getreducedcosts(self, first: int = 0, last: int = None) -> list:
+        if last is None:
+            last = self._numvar()
+        buf = (C.c_double * (last - first))()
+        self._check(_n.getreducedcosts(self.task, SOL.ITR, int(first), int(last), buf))
+        return list(buf)
+
+    def getintparam(self, param: int) -> int:
+        v = C.c_int(); self._check(_n.getintparam(self.task, int(param), byref(v))); return v.value
+
+    def getdouparam(self, param: int) -> float:
+        v = C.c_double(); self._check(_n.getdouparam(self.task, int(param), byref(v))); return v.value
+
+    def numvar(self) -> int:
+        return self._numvar()
+
+    def numcon(self) -> int:
+        return self._numcon()
+
+    def getbarxj(self, j: int = 0) -> list:
+        """Bar variable j as a full dim x dim row-major matrix (dim*dim values)."""
+        dim = C.c_int(); self._check(_n.getdimbarvarj(self.task, int(j), byref(dim)))
+        buf = (C.c_double * (dim.value * dim.value))()
+        self._check(_n.getbarxj(self.task, SOL.ITR, int(j), buf))
+        return list(buf)
+
+    def getbarsj(self, j: int = 0) -> list:
+        dim = C.c_int(); self._check(_n.getdimbarvarj(self.task, int(j), byref(dim)))
+        buf = (C.c_double * (dim.value * dim.value))()
+        self._check(_n.getbarsj(self.task, SOL.ITR, int(j), buf))
+        return list(buf)
+
+    def var_bounds(self, j: int, bk: int, lo: float = 0.0, up: float = 0.0) -> None:
+        self._check(_n.putvarbound(self.task, int(j), int(bk), float(lo), float(up)), "putvarbound")
+
+    def con_bounds(self, i: int, bk: int, lo: float = 0.0, up: float = 0.0) -> None:
+        self._check(_n.putconbound(self.task, int(i), int(bk), float(lo), float(up)), "putconbound")
+
+    def sense(self, sense: int) -> None:
+        self._check(_n.putobjsense(self.task, int(sense)), "putobjsense")
+
+    # -- file I/O ------------------------------------------------------------
+    def read(self, path: str) -> None:
+        self._check(_n.readdataautoformat(self.task, str(path).encode()), "readdataautoformat")
+
+    def write(self, path: str) -> None:
+        self._check(_n.writedata(self.task, str(path).encode()), "writedata")
+
+    # -- solve ---------------------------------------------------------------
+    def solve(self, which: int = SOL.ITR) -> Result:
+        rc = _n.optimize(self.task)
+        nv, nc = self._numvar(), self._numcon()
+        x = (C.c_double * nv)() if nv else (C.c_double * 0)()
+        y = (C.c_double * nc)() if nc else (C.c_double * 0)()
+        obj = C.c_double()
+        dual = C.c_double()
+        pinf = C.c_double()
+        sta = C.c_int()
+        pro = C.c_int()
+        # A non-OK rc can still carry a verdict (e.g. infeasible/unbounded): read
+        # the status regardless and let the caller decide.
+        if nv:
+            _n.getxx(self.task, int(which), x)
+        if nc:
+            _n.gety(self.task, int(which), y)
+        _n.getprimalobj(self.task, int(which), byref(obj))
+        _n.getdualobj(self.task, int(which), byref(dual))
+        _n.getprimalinfeas(self.task, int(which), byref(pinf))
+        _n.getsolsta(self.task, int(which), byref(sta))
+        _n.getprosta(self.task, int(which), byref(pro))
+        return Result(list(x), list(y), obj.value, dual.value, sta.value, pro.value, pinf.value, rc)
+
+    def close(self) -> None:
+        if self.task:
+            _n.deletetask(byref(self.task))
+            self.task = c_void_p()
+        if self.env:
+            _n.deleteenv(byref(self.env))
+            self.env = c_void_p()
+
+    def __enter__(self) -> "Model":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+
+__all__ = ["Model", "Result", "SolverError", "version", "BK", "SENSE", "SOL", "SOLSTA", "CT",
+           "SOL_ITR", "FUNCTIONS", "MISSING"]