scs 3.2.8__cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

scs/__init__.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python
+from warnings import warn
+from scipy import sparse
+from scs import _scs_direct
+
+__version__ = _scs_direct.version()
+__sizeof_int__ = _scs_direct.sizeof_int()
+__sizeof_float__ = _scs_direct.sizeof_float()
+
+_USE_INDIRECT_DEFAULT = False
+
+
+# SCS return integers correspond to one of these flags:
+# (copied from scs/include/glbopts.h)
+INFEASIBLE_INACCURATE = -7  # SCS best guess infeasible
+UNBOUNDED_INACCURATE = -6  # SCS best guess unbounded
+SIGINT = -5  # interrupted by sig int
+FAILED = -4  # SCS failed
+INDETERMINATE = -3  # indeterminate (norm too small)
+INFEASIBLE = -2  # primal infeasible, dual unbounded
+UNBOUNDED = -1  # primal unbounded, dual infeasible
+UNFINISHED = 0  # never returned, used as placeholder
+SOLVED = 1  # problem solved to desired accuracy
+SOLVED_INACCURATE = 2  # SCS best guess solved
+
+
+# Choose which SCS to import based on settings.
+def _select_scs_module(stgs):
+
+    if stgs.pop("gpu", False):  # False by default
+        if not stgs.pop("use_indirect", _USE_INDIRECT_DEFAULT):
+            raise NotImplementedError(
+                "For the GPU direct solver, pass `use_indirect=False cudss=True`.")
+        from scs import _scs_gpu
+        
+        return _scs_gpu
+
+    if stgs.pop("mkl", False):  # False by default
+        if stgs.pop("use_indirect", False):
+            raise NotImplementedError(
+                "MKL indirect solver not yet available, pass `use_indirect=False`."
+            )
+        from scs import _scs_mkl
+
+        return _scs_mkl
+
+    if stgs.pop("cudss", False):  # False by default
+        if stgs.pop("use_indirect", False):
+            raise NotImplementedError(
+                "cuDSS is a direct solver, pass `use_indirect=False`."
+            )
+        from scs import _scs_cudss
+
+        return _scs_cudss
+
+    if stgs.pop("use_indirect", _USE_INDIRECT_DEFAULT):
+        from scs import _scs_indirect
+
+        return _scs_indirect
+
+    return _scs_direct
+
+
+class SCS(object):
+    def __init__(self, data, cone, **settings):
+        """Initialize the SCS solver.
+
+        @param data     Dictionary containing keys `P`, `A`, `b`, `c`.
+        @param cone     Dictionary containing cone information.
+        @param settings Settings as kwargs, see docs.
+
+        """
+        self._settings = settings
+        if not data or not cone:
+            raise ValueError("Missing data or cone information")
+
+        if "b" not in data or "c" not in data:
+            raise ValueError("Missing one of b, c from data dictionary")
+        if "A" not in data:
+            raise ValueError("Missing A from data dictionary")
+
+        A = data["A"]
+        b = data["b"]
+        c = data["c"]
+
+        if A is None or b is None or c is None:
+            raise ValueError("Incomplete data specification")
+
+        if not sparse.issparse(A):
+            raise TypeError("A is required to be a sparse matrix")
+        if not A.format == "csc":
+            warn(
+                "Converting A to a CSC (compressed sparse column) matrix;"
+                " may take a while."
+            )
+            A = A.tocsc()
+
+        if sparse.issparse(b):
+            b = b.todense()
+
+        if sparse.issparse(c):
+            c = c.todense()
+
+        m = len(b)
+        n = len(c)
+
+        if not A.has_sorted_indices:
+            A.sort_indices()
+        Adata, Aindices, Acolptr = A.data, A.indices, A.indptr
+        if A.shape != (m, n):
+            raise ValueError("A shape not compatible with b,c")
+
+        Pdata, Pindices, Pcolptr = None, None, None
+        if "P" in data:
+            P = data["P"]
+            if P is not None:
+                if not sparse.issparse(P):
+                    raise TypeError("P is required to be a sparse matrix")
+                if P.shape != (n, n):
+                    raise ValueError("P shape not compatible with A,b,c")
+                if not P.format == "csc":
+                    warn(
+                        "Converting P to a CSC (compressed sparse column) "
+                        "matrix; may take a while."
+                    )
+                    P = P.tocsc()
+                # extract upper triangular component only
+                if sparse.tril(P, -1).data.size > 0:
+                    P = sparse.triu(P, format="csc")
+                if not P.has_sorted_indices:
+                    P.sort_indices()
+                Pdata, Pindices, Pcolptr = P.data, P.indices, P.indptr
+
+        # Which scs are we using (scs_direct, scs_indirect, ...)
+        _scs = _select_scs_module(self._settings)
+
+        # Initialize solver
+        self._solver = _scs.SCS(
+            (m, n),
+            Adata,
+            Aindices,
+            Acolptr,
+            Pdata,
+            Pindices,
+            Pcolptr,
+            b,
+            c,
+            cone,
+            **self._settings
+        )
+
+    def solve(self, warm_start=True, x=None, y=None, s=None):
+        """Solve the optimization problem.
+
+        @param warm_start   Whether to warm-start. By default the solution of
+                            the previous problem is used as the warm-start. The
+                            warm-start can be overriden to another value by
+                            passing `x`, `y`, `s` args.
+        @param x            Primal warm-start override.
+        @param y            Dual warm-start override.
+        @param s            Slack warm-start override.
+
+        @return dictionary with solution with keys:
+             'x' - primal solution
+             's' - primal slack solution
+             'y' - dual solution
+             'info' - information dictionary (see docs)
+        """
+        return self._solver.solve(warm_start, x, y, s)
+
+    def update(self, b=None, c=None):
+        """Update the `b` vector, `c` vector, or both, before another solve.
+
+        After a solve we can reuse the SCS workspace in another solve if the
+        only problem data that has changed are the `b` and `c` vectors.
+
+        @param  b   New `b` vector.
+        @param  c	New `c` vector.
+
+        """
+        self._solver.update(b, c)
+
+
+# Backwards compatible helper function that simply calls the main API.
+def solve(data, cone, **settings):
+    solver = SCS(data, cone, **settings)
+
+    # Hack out the warm start data from old API
+    x = y = s = None
+    if "x" in data:
+        x = data["x"]
+    if "y" in data:
+        y = data["y"]
+    if "s" in data:
+        s = data["s"]
+
+    return solver.solve(warm_start=True, x=x, y=y, s=s)

scs-3.2.8.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Brendan O'Donoghue
+
+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.

scs-3.2.8.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: scs
+Version: 3.2.8
+Summary: Splitting conic solver
+Author-Email: Brendan O'Donoghue <bodonoghue85@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2017 Brendan O'Donoghue
+         
+         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.
+         
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+scs-python
+===
+
+[![Build Status](https://github.com/bodono/scs-python/actions/workflows/build.yml/badge.svg)](https://github.com/bodono/scs-python/actions/workflows/build.yml)
+[![Documentation](https://img.shields.io/badge/docs-online-brightgreen?logo=read-the-docs&style=flat)](https://www.cvxgrp.org/scs/)
+[![PyPI Downloads/Month](https://static.pepy.tech/personalized-badge/scs?period=month&units=abbreviation&left_color=grey&right_color=brightgreen&left_text=downloads/month)](https://pepy.tech/project/scs)
+
+Python interface for [SCS](https://github.com/cvxgrp/scs) 3.0.0 and higher.
+The full documentation is available [here](https://www.cvxgrp.org/scs/).

scs-3.2.8.dist-info/RECORD

@@ -0,0 +1,9 @@
+scs/__init__.py,sha256=96fIOXkd0xJ5mU4-ild1Km5__fJb1n41NxvRRQdBBpE,6440
+scs/_scs_direct.cpython-311-aarch64-linux-gnu.so,sha256=vuc9MfWqYti6mKFLsfO-EOT1DT7ymjBzvVIRAjCnXnA,394905
+scs/_scs_indirect.cpython-311-aarch64-linux-gnu.so,sha256=37fBdzg_KKes2VmtP3HdRfZLSA81-mImMeMTyPnopmo,329353
+scs.libs/libgfortran-8a9a71bc.so.5.0.0,sha256=atxs0oHDWcJ-ksauJ9hkc4MhFQcgOo5GCW3DTFFCM7U,1484433
+scs.libs/libopenblas-r0-e9c9f581.3.15.so,sha256=5MfzRhIiZc9VJaAAkM6Pwy0YFK5LEg-UcVHLbW5hUmE,10044585
+scs-3.2.8.dist-info/LICENSE,sha256=lxIl5g3kUJCLfZjb72Z7K6XviabPAckIClya6BP-0Bg,1075
+scs-3.2.8.dist-info/METADATA,sha256=NXOnuqeyO5Kl7oCCTUjivQngCggQqXZN25VJyCSVxGU,2806
+scs-3.2.8.dist-info/WHEEL,sha256=AhtX1nhu7xc_MUHbXd_hCKNUrnjYpCoBbmQzU_zY5w0,140
+scs-3.2.8.dist-info/RECORD,,

scs-3.2.8.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_27_aarch64
+Tag: cp311-cp311-manylinux_2_28_aarch64
+