sip-python 0.0.2__tar.gz → 0.0.3__tar.gz

{sip_python-0.0.2 → sip_python-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sip_python
-Version: 0.0.2
+Version: 0.0.3
 Summary: Python bindings for the SIP solver.
 Author-email: João Sousa-Pinto <joaospinto@gmail.com>
 Project-URL: Homepage, https://github.com/joaospinto/sip_python

{sip_python-0.0.2 → sip_python-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sip_python"
-version = "0.0.2"
+version = "0.0.3"
 description = "Python bindings for the SIP solver."
 readme = "README.md"
 requires-python = ">=3.10"

{sip_python-0.0.2 → sip_python-0.0.3}/setup.py

@@ -102,10 +102,11 @@ class BuildBazelExtension(build_ext.build_ext):
             "run",
             ext.bazel_target,
             f"--symlink_prefix={temp_path / 'bazel-'}",
-            f"--compilation_mode={'dbg' if self.debug else 'opt'}",
             f"--target_python_version={python_version}",
         ]
 
+        if self.debug:
+            bazel_argv += ["--config=debug"]
         if ext.py_limited_api:
             bazel_argv += ["--py_limited_api=cp312"]
         if ext.free_threaded:

sip_python-0.0.3/src/sip_python/__init__.py

@@ -0,0 +1,7 @@
+from .sip_python_ext import *
+from .helpers import (
+    get_K,
+    get_kkt_perm_inv,
+    get_kkt_and_L_nnzs,
+    get_kkt_perm_inv_and_nnzs,
+)

sip_python-0.0.3/src/sip_python/helpers.py

@@ -0,0 +1,125 @@
+import ctypes
+import os
+import warnings
+
+import numpy as np
+from scipy import sparse as spa
+from scipy.sparse.csgraph import reverse_cuthill_mckee
+
+from .sip_python_ext import getLnnz
+
+# Try to load libamd directly for fast AMD ordering.
+_libamd = None
+try:
+    _dylibs_dir = os.path.join(
+        os.path.dirname(__import__("cvxopt").__file__), ".dylibs"
+    )
+    for f in os.listdir(_dylibs_dir):
+        if f.startswith("libamd"):
+            _libamd = ctypes.CDLL(os.path.join(_dylibs_dir, f))
+            _libamd.amd_l_order.restype = ctypes.c_int
+            _libamd.amd_l_order.argtypes = [
+                ctypes.c_long,
+                ctypes.POINTER(ctypes.c_long),
+                ctypes.POINTER(ctypes.c_long),
+                ctypes.POINTER(ctypes.c_long),
+                ctypes.c_void_p,
+                ctypes.c_void_p,
+            ]
+            break
+except Exception:
+    pass
+
+
+def _amd_order(K_csc):
+    """Compute AMD ordering on a CSC matrix via libamd."""
+    K_sym = (K_csc + K_csc.T).tocsc()
+    K_sym.sort_indices()
+    n = K_sym.shape[0]
+    Ap = K_sym.indptr.astype(np.int64)
+    Ai = K_sym.indices.astype(np.int64)
+    perm = np.empty(n, dtype=np.int64)
+    ret = _libamd.amd_l_order(
+        n,
+        Ap.ctypes.data_as(ctypes.POINTER(ctypes.c_long)),
+        Ai.ctypes.data_as(ctypes.POINTER(ctypes.c_long)),
+        perm.ctypes.data_as(ctypes.POINTER(ctypes.c_long)),
+        None,
+        None,
+    )
+    if ret != 0:
+        raise RuntimeError(f"amd_l_order failed with return code {ret}")
+    return perm.astype(np.intp)
+
+
+def get_K(P, A, G):
+    # K = [ P + r1 I_x      A.T        G.T   ]
+    #     [     A        -r2 * I_y      0    ]
+    #     [     G            0       -r3 I_z ]
+
+    if isinstance(P, np.ndarray):
+        P = spa.csc_matrix(P)
+
+    if isinstance(A, np.ndarray):
+        A = spa.csr_matrix(A)
+
+    if isinstance(G, np.ndarray):
+        G = spa.csr_matrix(G)
+
+    x_dim = P.shape[0]
+    s_dim = G.shape[0]
+    y_dim = A.shape[0]
+
+    mod_P = spa.csc_matrix.copy(P)
+    mod_P.data[:] = 1.0
+
+    Z = spa.csc_matrix((y_dim, s_dim))
+
+    K = spa.block_array(
+        blocks=[
+            [mod_P + spa.eye(x_dim), A.T, G.T],
+            [A, -spa.eye(y_dim), Z],
+            [G, Z.T, -spa.eye(s_dim)],
+        ],
+        format="coo",
+    )
+
+    return K
+
+
+def _get_kkt_perm(K, verbose):
+    K_csc = spa.csc_matrix(K)
+    if _libamd is not None:
+        return _amd_order(K_csc)
+    if verbose:
+        warnings.warn(
+            "cvxopt not installed; using reverse Cuthill-McKee (RCM) "
+            "instead of approximate minimum degree (AMD)."
+        )
+    return reverse_cuthill_mckee(K_csc)
+
+
+def get_kkt_perm_inv(K, verbose=True):
+    perm = _get_kkt_perm(K, verbose)
+
+    perm_inv = np.empty_like(perm)
+    perm_inv[perm] = np.arange(perm_inv.shape[0])
+
+    return perm_inv
+
+
+def get_kkt_and_L_nnzs(K, perm_inv):
+    permuted_K = spa.coo_matrix.copy(K)
+    permuted_K.row = perm_inv[permuted_K.row]
+    permuted_K.col = perm_inv[permuted_K.col]
+
+    kkt_L_nnz = getLnnz(spa.triu(permuted_K))
+
+    return K.nnz, kkt_L_nnz
+
+
+def get_kkt_perm_inv_and_nnzs(P, A, G, verbose=True):
+    K = get_K(P, A, G)
+    perm_inv = get_kkt_perm_inv(K, verbose)
+    K_nnz, kkt_L_nnz = get_kkt_and_L_nnzs(K, perm_inv)
+    return perm_inv, K_nnz, kkt_L_nnz

{sip_python-0.0.2 → sip_python-0.0.3}/src/sip_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sip_python
-Version: 0.0.2
+Version: 0.0.3
 Summary: Python bindings for the SIP solver.
 Author-email: João Sousa-Pinto <joaospinto@gmail.com>
 Project-URL: Homepage, https://github.com/joaospinto/sip_python

{sip_python-0.0.2 → sip_python-0.0.3}/src/sip_python.egg-info/SOURCES.txt

@@ -9,5 +9,7 @@ src/sip_python.egg-info/SOURCES.txt
 src/sip_python.egg-info/dependency_links.txt
 src/sip_python.egg-info/requires.txt
 src/sip_python.egg-info/top_level.txt
+tests/test_simple_constrained_lqr.py
+tests/test_simple_lqr.py
 tests/test_simple_nlp.py
 tests/test_simple_qp.py

sip_python-0.0.3/tests/test_simple_constrained_lqr.py

@@ -0,0 +1,195 @@
+import pytest
+import jax
+from jax import numpy as jnp
+
+import numpy as np
+from scipy import sparse as sp
+
+from sip_python import (
+    get_kkt_perm_inv_and_nnzs,
+    ModelCallbackInput,
+    ModelCallbackOutput,
+    ProblemDimensions,
+    QDLDLSettings,
+    Settings,
+    Solver,
+    Status,
+    Variables,
+)
+
+jax.config.update("jax_enable_x64", True)
+
+
+def test_simple_constrained_lqr():
+    ss = Settings()
+    ss.max_kkt_violation = 1e-6
+    ss.enable_elastics = True
+    ss.elastic_var_cost_coeff = 1e6
+    ss.assert_checks_pass = True
+    ss.penalty_parameter_increase_factor = 2.0
+    ss.mu_update_factor = 0.9
+    ss.max_iterations = 200
+    ss.max_ls_iterations = 1000
+    ss.print_logs = False
+    ss.print_line_search_logs = False
+    ss.print_search_direction_logs = False
+    ss.print_derivative_check_logs = False
+
+    x_dim = 2
+    u_dim = 1
+    g_dim = 2
+    c_dim = 1
+    T = 100
+
+    dt = 0.1
+
+    @jax.jit
+    def split(x):
+        x = jnp.concatenate([x, jnp.zeros(u_dim)])
+        x = x.reshape([T + 1, x_dim + u_dim])
+        X = x[:, :x_dim]
+        U = x[:T, x_dim:]
+        return X, U
+
+    @jax.jit
+    def f(x):
+        X, U = split(x)
+        stagewise_costs = jax.vmap(
+            lambda i: 0.5 * X[i, 0] ** 2
+            + 0.5 * 0.1 * X[i, 1] ** 2
+            + 0.5 * 0.1 * U[i, 0] ** 2
+        )(jnp.arange(T))
+        terminal_cost = 0.5 * X[T, 0] ** 2 + 0.5 * 0.1 * X[T, 1] ** 2
+        return stagewise_costs.sum() + terminal_cost
+
+    @jax.jit
+    def c(x):
+        x_0 = jnp.array([0.0, 10.0])
+        A = jnp.array([[1.0, dt], [0.0, 1.0]])
+        B = jnp.array([[dt**2 / 2], [dt]])
+        X, U = split(x)
+
+        out = jnp.concatenate(
+            [
+                x_0 - X[0],
+                jnp.array(
+                    [
+                        0.0,
+                    ]
+                ),
+                jax.vmap(
+                    lambda i: jnp.concatenate(
+                        [
+                            (A @ X[i] + B @ U[i] - X[i + 1]),
+                            jnp.array(
+                                [
+                                    jnp.where(i + 1 == T, X[i + 1, 1], 0.0),
+                                ]
+                            ),
+                        ]
+                    )
+                )(jnp.arange(T)).flatten(),
+            ]
+        )
+        return out
+
+    @jax.jit
+    def g(x):
+        _X, U = split(x)
+        return jnp.concatenate(
+            [
+                jax.vmap(lambda i: jnp.array([U[i, 0] - 2.0, -U[i, 0] - 2.0]))(
+                    jnp.arange(T)
+                ).flatten(),
+                jnp.zeros(g_dim),
+            ]
+        )
+
+    @jax.jit
+    def grad_f(x):
+        return jax.grad(f)(x)
+
+    @jax.jit
+    def approx_upp_hess_f(x):
+        def proj_psd(Q, delta=1e-6):
+            S, _V = jnp.linalg.eigh(Q)
+            k = -jnp.minimum(jnp.min(S), 0.0) + delta
+            return Q + k * jnp.eye(Q.shape[0])
+
+        return jnp.triu(proj_psd(jax.hessian(f)(x)))
+
+    @jax.jit
+    def jac_c(x):
+        return jax.jacfwd(c)(x)
+
+    @jax.jit
+    def jac_g(x):
+        return jax.jacfwd(g)(x)
+
+    pd = ProblemDimensions()
+    pd.x_dim = T * (x_dim + u_dim) + x_dim
+    pd.s_dim = (T + 1) * g_dim
+    pd.y_dim = (T + 1) * (x_dim + c_dim)
+
+    mock_x = jnp.ones(
+        [
+            pd.x_dim,
+        ]
+    )
+    jac_c_nnz_pattern = np.array(jac_c(mock_x))
+    jac_g_nnz_pattern = np.array(jac_g(mock_x))
+    upper_L_hess_nnz_pattern = np.array(approx_upp_hess_f(mock_x))
+
+    jac_c_nnz_pattern_sp = sp.csr_matrix(jac_c_nnz_pattern)
+    jac_g_nnz_pattern_sp = sp.csr_matrix(jac_g_nnz_pattern)
+    upper_L_hess_nnz_pattern_sp = sp.csc_matrix(upper_L_hess_nnz_pattern)
+
+    qs = QDLDLSettings()
+    qs.permute_kkt_system = True
+    qs.kkt_pinv, pd.kkt_nnz, pd.kkt_L_nnz = get_kkt_perm_inv_and_nnzs(
+        P=upper_L_hess_nnz_pattern_sp,
+        A=jac_c_nnz_pattern_sp,
+        G=jac_g_nnz_pattern_sp,
+    )
+
+    pd.upper_hessian_lagrangian_nnz = upper_L_hess_nnz_pattern_sp.nnz
+    pd.jacobian_c_nnz = jac_c_nnz_pattern_sp.nnz
+    pd.jacobian_g_nnz = jac_g_nnz_pattern_sp.nnz
+    pd.is_jacobian_c_transposed = True
+    pd.is_jacobian_g_transposed = True
+
+    def mc(mci: ModelCallbackInput) -> ModelCallbackOutput:
+        mco = ModelCallbackOutput()
+
+        mco.f = f(mci.x)
+        mco.c = np.array(c(mci.x))
+        mco.g = np.array(g(mci.x))
+
+        mco.gradient_f = np.array(grad_f(mci.x))
+
+        C = np.array(jac_c(mci.x))
+        jac_c_nnz_pattern_sp.data = C[jac_c_nnz_pattern != 0.0]
+        mco.jacobian_c = jac_c_nnz_pattern_sp
+
+        G = np.array(jac_g(mci.x))
+        jac_g_nnz_pattern_sp.data = G[jac_g_nnz_pattern != 0.0]
+        mco.jacobian_g = jac_g_nnz_pattern_sp
+
+        upp_hess_L = np.array(approx_upp_hess_f(mci.x))
+        upper_L_hess_nnz_pattern_sp.data = upp_hess_L[upper_L_hess_nnz_pattern != 0.0]
+        mco.upper_hessian_lagrangian = upper_L_hess_nnz_pattern_sp
+
+        return mco
+
+    solver = Solver(ss, qs, pd, mc)
+
+    vars = Variables(pd)
+    vars.x[:] = 0.0
+    vars.s[:] = 1.0
+    vars.y[:] = 0.0
+    vars.e[:] = 0.0
+    vars.z[:] = 1.0
+
+    output = solver.solve(vars)
+
+    assert output.exit_status == Status.SOLVED

sip_python-0.0.3/tests/test_simple_lqr.py

@@ -0,0 +1,171 @@
+import pytest
+import jax
+from jax import numpy as jnp
+
+import numpy as np
+from scipy import sparse as sp
+
+from sip_python import (
+    get_kkt_perm_inv_and_nnzs,
+    ModelCallbackInput,
+    ModelCallbackOutput,
+    ProblemDimensions,
+    QDLDLSettings,
+    Settings,
+    Solver,
+    Status,
+    Variables,
+)
+
+jax.config.update("jax_enable_x64", True)
+
+
+def test_simple_lqr():
+    ss = Settings()
+    ss.max_kkt_violation = 1e-6
+    ss.enable_elastics = True
+    ss.elastic_var_cost_coeff = 1e6
+    ss.assert_checks_pass = True
+    ss.penalty_parameter_increase_factor = 2.0
+    ss.mu_update_factor = 0.9
+    ss.print_logs = False
+    ss.print_line_search_logs = False
+    ss.print_search_direction_logs = False
+    ss.print_derivative_check_logs = False
+
+    x_dim = 2
+    u_dim = 1
+    g_dim = 0
+    c_dim = 0
+    T = 100
+
+    dt = 0.1
+
+    @jax.jit
+    def split(x):
+        x = jnp.concatenate([x, jnp.zeros(u_dim)])
+        x = x.reshape([T + 1, x_dim + u_dim])
+        X = x[:, :x_dim]
+        U = x[:T, x_dim:]
+        return X, U
+
+    @jax.jit
+    def f(x):
+        X, U = split(x)
+        stagewise_costs = jax.vmap(
+            lambda i: 0.5 * X[i, 0] ** 2
+            + 0.5 * 0.1 * X[i, 1] ** 2
+            + 0.5 * 0.1 * U[i, 0] ** 2
+        )(jnp.arange(T))
+        terminal_cost = 0.5 * X[T, 0] ** 2 + 0.5 * 0.1 * X[T, 1] ** 2
+        return stagewise_costs.sum() + terminal_cost
+
+    @jax.jit
+    def c(x):
+        x_0 = jnp.array([0.0, 10.0])
+        A = jnp.array([[1.0, dt], [0.0, 1.0]])
+        B = jnp.array([[dt**2 / 2], [dt]])
+        X, U = split(x)
+
+        out = jnp.concatenate(
+            [
+                x_0 - X[0],
+                jax.vmap(lambda i: A @ X[i] + B @ U[i] - X[i + 1])(
+                    jnp.arange(T)
+                ).flatten(),
+            ]
+        )
+        return out
+
+    @jax.jit
+    def g(x):
+        return jnp.array([])
+
+    @jax.jit
+    def grad_f(x):
+        return jax.grad(f)(x)
+
+    @jax.jit
+    def approx_upp_hess_f(x):
+        def proj_psd(Q, delta=1e-6):
+            S, _V = jnp.linalg.eigh(Q)
+            k = -jnp.minimum(jnp.min(S), 0.0) + delta
+            return Q + k * jnp.eye(Q.shape[0])
+
+        return jnp.triu(proj_psd(jax.hessian(f)(x)))
+
+    @jax.jit
+    def jac_c(x):
+        return jax.jacfwd(c)(x)
+
+    @jax.jit
+    def jac_g(x):
+        return jax.jacfwd(g)(x)
+
+    pd = ProblemDimensions()
+    pd.x_dim = T * (x_dim + u_dim) + x_dim
+    pd.s_dim = (T + 1) * g_dim
+    pd.y_dim = (T + 1) * (x_dim + c_dim)
+
+    mock_x = jnp.ones(
+        [
+            pd.x_dim,
+        ]
+    )
+    jac_c_nnz_pattern = np.array(jac_c(mock_x))
+    jac_g_nnz_pattern = np.array(jac_g(mock_x))
+    upper_L_hess_nnz_pattern = np.array(approx_upp_hess_f(mock_x))
+
+    jac_c_nnz_pattern_sp = sp.csr_matrix(jac_c_nnz_pattern)
+    jac_g_nnz_pattern_sp = sp.csr_matrix(jac_g_nnz_pattern)
+    upper_L_hess_nnz_pattern_sp = sp.csc_matrix(upper_L_hess_nnz_pattern)
+
+    qs = QDLDLSettings()
+    qs.permute_kkt_system = True
+    qs.kkt_pinv, pd.kkt_nnz, pd.kkt_L_nnz = get_kkt_perm_inv_and_nnzs(
+        P=upper_L_hess_nnz_pattern_sp,
+        A=jac_c_nnz_pattern_sp,
+        G=jac_g_nnz_pattern_sp,
+    )
+
+    pd.upper_hessian_lagrangian_nnz = upper_L_hess_nnz_pattern_sp.nnz
+    pd.jacobian_c_nnz = jac_c_nnz_pattern_sp.nnz
+    pd.jacobian_g_nnz = jac_g_nnz_pattern_sp.nnz
+    pd.is_jacobian_c_transposed = True
+    pd.is_jacobian_g_transposed = True
+
+    def mc(mci: ModelCallbackInput) -> ModelCallbackOutput:
+        mco = ModelCallbackOutput()
+
+        mco.f = f(mci.x)
+        mco.c = np.array(c(mci.x))
+        mco.g = np.array(g(mci.x))
+
+        mco.gradient_f = np.array(grad_f(mci.x))
+
+        C = np.array(jac_c(mci.x))
+        jac_c_nnz_pattern_sp.data = C[jac_c_nnz_pattern != 0.0]
+        mco.jacobian_c = jac_c_nnz_pattern_sp
+
+        G = np.array(jac_g(mci.x))
+        jac_g_nnz_pattern_sp.data = G[jac_g_nnz_pattern != 0.0]
+        mco.jacobian_g = jac_g_nnz_pattern_sp
+
+        upp_hess_L = np.array(approx_upp_hess_f(mci.x))
+        upper_L_hess_nnz_pattern_sp.data = upp_hess_L[upper_L_hess_nnz_pattern != 0.0]
+        mco.upper_hessian_lagrangian = upper_L_hess_nnz_pattern_sp
+
+        return mco
+
+    solver = Solver(ss, qs, pd, mc)
+
+    vars = Variables(pd)
+    vars.x[:] = 0.0
+    vars.s[:] = 1.0
+    vars.y[:] = 0.0
+    vars.e[:] = 0.0
+    vars.z[:] = 1.0
+
+    output = solver.solve(vars)
+
+    assert output.exit_status == Status.SOLVED

{sip_python-0.0.2 → sip_python-0.0.3}/tests/test_simple_nlp.py

@@ -1,6 +1,12 @@
+import pytest
+import jax
+from jax import numpy as jnp
+
+import numpy as np
+from scipy import sparse as sp
+
 from sip_python import (
-    get_kkt_and_L_nnzs,
-    get_kkt_perm_inv,
+    get_kkt_perm_inv_and_nnzs,
     ModelCallbackInput,
     ModelCallbackOutput,
     ProblemDimensions,
@@ -11,17 +17,8 @@ from sip_python import (
     Variables,
 )
 
-import pytest
-
-import jax
-from jax import numpy as jnp
-
 jax.config.update("jax_enable_x64", True)
 
-import numpy as np
-
-from scipy import sparse as sp
-
 
 def test_simple_qp():
     ss = Settings()
@@ -29,6 +26,10 @@ def test_simple_qp():
     ss.enable_elastics = True
     ss.elastic_var_cost_coeff = 1e6
     ss.assert_checks_pass = True
+    ss.print_logs = False
+    ss.print_line_search_logs = False
+    ss.print_search_direction_logs = False
+    ss.print_derivative_check_logs = False
 
     @jax.jit
     def f(x):
@@ -83,27 +84,23 @@ def test_simple_qp():
     jac_g_nnz_pattern_sp = sp.csr_matrix(jac_g_nnz_pattern)
     upper_L_hess_nnz_pattern_sp = sp.csc_matrix(upper_L_hess_nnz_pattern)
 
+    pd = ProblemDimensions()
+    pd.x_dim = x_dim
+    pd.s_dim = jac_g_nnz_pattern_sp.shape[0]
+    pd.y_dim = jac_c_nnz_pattern_sp.shape[0]
+
     qs = QDLDLSettings()
     qs.permute_kkt_system = True
-    qs.kkt_pinv = get_kkt_perm_inv(
+    qs.kkt_pinv, pd.kkt_nnz, pd.kkt_L_nnz = get_kkt_perm_inv_and_nnzs(
         P=upper_L_hess_nnz_pattern_sp,
         A=jac_c_nnz_pattern_sp,
         G=jac_g_nnz_pattern_sp,
     )
 
-    pd = ProblemDimensions()
-    pd.x_dim = x_dim
-    pd.s_dim = 2
-    pd.y_dim = 0
     pd.upper_hessian_lagrangian_nnz = upper_L_hess_nnz_pattern_sp.nnz
     pd.jacobian_c_nnz = jac_c_nnz_pattern_sp.nnz
     pd.jacobian_g_nnz = jac_g_nnz_pattern_sp.nnz
-    pd.kkt_nnz, pd.kkt_L_nnz = get_kkt_and_L_nnzs(
-        P=upper_L_hess_nnz_pattern_sp,
-        A=jac_c_nnz_pattern_sp,
-        G=jac_g_nnz_pattern_sp,
-        perm_inv=qs.kkt_pinv,
-    )
+
     pd.is_jacobian_c_transposed = True
     pd.is_jacobian_g_transposed = True
 

{sip_python-0.0.2 → sip_python-0.0.3}/tests/test_simple_qp.py

@@ -1,6 +1,12 @@
+import pytest
+import jax
+from jax import numpy as jnp
+
+import numpy as np
+from scipy import sparse as sp
+
 from sip_python import (
-    get_kkt_and_L_nnzs,
-    get_kkt_perm_inv,
+    get_kkt_perm_inv_and_nnzs,
     ModelCallbackInput,
     ModelCallbackOutput,
     ProblemDimensions,
@@ -11,17 +17,8 @@ from sip_python import (
     Variables,
 )
 
-import pytest
-
-import jax
-from jax import numpy as jnp
-
 jax.config.update("jax_enable_x64", True)
 
-import numpy as np
-
-from scipy import sparse as sp
-
 
 def test_simple_qp():
     ss = Settings()
@@ -29,6 +26,10 @@ def test_simple_qp():
     ss.enable_elastics = True
     ss.elastic_var_cost_coeff = 1e6
     ss.assert_checks_pass = True
+    ss.print_logs = False
+    ss.print_line_search_logs = False
+    ss.print_search_direction_logs = False
+    ss.print_derivative_check_logs = False
 
     @jax.jit
     def f(x):
@@ -82,27 +83,23 @@ def test_simple_qp():
     jac_g_nnz_pattern_sp = sp.csr_matrix(jac_g_nnz_pattern)
     upper_L_hess_nnz_pattern_sp = sp.csc_matrix(upper_L_hess_nnz_pattern)
 
+    pd = ProblemDimensions()
+    pd.x_dim = x_dim
+    pd.s_dim = jac_g_nnz_pattern_sp.shape[0]
+    pd.y_dim = jac_c_nnz_pattern_sp.shape[0]
+
     qs = QDLDLSettings()
     qs.permute_kkt_system = True
-    qs.kkt_pinv = get_kkt_perm_inv(
+    qs.kkt_pinv, pd.kkt_nnz, pd.kkt_L_nnz = get_kkt_perm_inv_and_nnzs(
         P=upper_L_hess_nnz_pattern_sp,
         A=jac_c_nnz_pattern_sp,
         G=jac_g_nnz_pattern_sp,
     )
 
-    pd = ProblemDimensions()
-    pd.x_dim = x_dim
-    pd.s_dim = 4
-    pd.y_dim = 1
     pd.upper_hessian_lagrangian_nnz = upper_L_hess_nnz_pattern_sp.nnz
     pd.jacobian_c_nnz = jac_c_nnz_pattern_sp.nnz
     pd.jacobian_g_nnz = jac_g_nnz_pattern_sp.nnz
-    pd.kkt_nnz, pd.kkt_L_nnz = get_kkt_and_L_nnzs(
-        P=upper_L_hess_nnz_pattern_sp,
-        A=jac_c_nnz_pattern_sp,
-        G=jac_g_nnz_pattern_sp,
-        perm_inv=qs.kkt_pinv,
-    )
+
     pd.is_jacobian_c_transposed = True
     pd.is_jacobian_g_transposed = True
 

sip_python-0.0.2/src/sip_python/__init__.py

@@ -1,2 +0,0 @@
-from .sip_python_ext import *
-from .helpers import get_kkt_perm_inv, get_kkt_and_L_nnzs

sip_python-0.0.2/src/sip_python/helpers.py

@@ -1,89 +0,0 @@
-import warnings
-
-import numpy as np
-from scipy import sparse as spa
-
-from .sip_python_ext import getLnnz
-
-
-_cvxopt_available = False
-try:
-    from cvxopt import amd, spmatrix
-
-    _cvxopt_available = True
-except ImportError:
-    from scipy.sparse.csgraph import reverse_cuthill_mckee
-
-
-def _get_K(P, A, G):
-    # K = [ P + r1 I_x      A.T        G.T   ]
-    #     [     A        -r2 * I_y      0    ]
-    #     [     G            0       -r3 I_z ]
-
-    if isinstance(P, np.ndarray):
-        P = spa.csc_matrix(P)
-
-    if isinstance(A, np.ndarray):
-        A = spa.csr_matrix(A)
-
-    if isinstance(G, np.ndarray):
-        G = spa.csr_matrix(G)
-
-    x_dim = P.shape[0]
-    s_dim = G.shape[0]
-    y_dim = A.shape[0]
-
-    mod_P = spa.csc_matrix.copy(P)
-    mod_P.data[:] = 1.0
-
-    Z = spa.csc_matrix((y_dim, s_dim))
-
-    K = spa.block_array(
-        blocks=[
-            [mod_P + spa.eye(x_dim), A.T, G.T],
-            [A, -spa.eye(y_dim), Z],
-            [G, Z.T, -spa.eye(s_dim)],
-        ],
-        format="coo",
-    )
-
-    return K
-
-
-def _get_kkt_perm(P, A, G, verbose):
-    K = _get_K(P=P, A=A, G=G)
-
-    if _cvxopt_available:
-        K_cvxopt = spmatrix(
-            I=K.row,
-            J=K.col,
-            V=K.data,
-        )
-        return np.array(list(amd.order(K_cvxopt)))
-    if verbose:
-        warnings.warn(
-            "cvxopt not installed; using reverse Cuthill-McKee (RCM) "
-            "instead of approximate minimum degree (AMD)."
-        )
-    return reverse_cuthill_mckee(spa.csc_matrix(K))
-
-
-def get_kkt_perm_inv(P, A, G, verbose=True):
-    perm = _get_kkt_perm(P=P, A=A, G=G, verbose=verbose)
-
-    perm_inv = np.empty_like(perm)
-    perm_inv[perm] = np.arange(perm_inv.shape[0])
-
-    return perm_inv
-
-
-def get_kkt_and_L_nnzs(P, A, G, perm_inv):
-    K = _get_K(P=P, A=A, G=G)
-
-    permuted_K = spa.coo_matrix.copy(K)
-    permuted_K.row = perm_inv[permuted_K.row]
-    permuted_K.col = perm_inv[permuted_K.col]
-
-    kkt_L_nnz = getLnnz(spa.triu(permuted_K))
-
-    return K.nnz, kkt_L_nnz