sip-python 0.0.1__tar.gz

sip_python-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 João Sousa Pinto
+
+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.

sip_python-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: sip_python
+Version: 0.0.1
+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
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+# sip_python
+[![pip](https://github.com/joaospinto/sip_python/actions/workflows/pip.yml/badge.svg)](https://github.com/joaospinto/sip_python/actions?query=workflow%3Apip)
+[![wheels](https://github.com/joaospinto/sip_python/actions/workflows/wheels.yml/badge.svg)](https://github.com/joaospinto/sip_python/actions?query=workflow%3Awheels)
+
+Python bindings for the [SIP](https://github.com/joaospinto/sip) solver.

sip_python-0.0.1/README.md

@@ -0,0 +1,5 @@
+# sip_python
+[![pip](https://github.com/joaospinto/sip_python/actions/workflows/pip.yml/badge.svg)](https://github.com/joaospinto/sip_python/actions?query=workflow%3Apip)
+[![wheels](https://github.com/joaospinto/sip_python/actions/workflows/wheels.yml/badge.svg)](https://github.com/joaospinto/sip_python/actions?query=workflow%3Awheels)
+
+Python bindings for the [SIP](https://github.com/joaospinto/sip) solver.

sip_python-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sip_python"
+version = "0.0.1"
+description = "Python bindings for the SIP solver."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "João Sousa-Pinto", email = "joaospinto@gmail.com" }]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "numpy",
+    "scipy",
+]
+
+[project.urls]
+Homepage = "https://github.com/joaospinto/sip_python"

sip_python-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sip_python-0.0.1/setup.py

@@ -0,0 +1,163 @@
+import contextlib
+import os
+import platform
+import re
+import shutil
+import sys
+from pathlib import Path
+from collections.abc import Generator
+
+import setuptools
+from setuptools.command import build_ext
+
+# free-threaded build option, requires Python 3.13+.
+# Source: https://docs.python.org/3/howto/free-threading-python.html#identifying-free-threaded-python
+free_threaded = "experimental free-threading build" in sys.version
+# SABI-related options. Requires that each Python interpreter
+# (hermetic or not) participating is of the same major-minor version.
+# Cannot be used together with free-threading.
+py_limited_api = sys.version_info >= (3, 12) and not free_threaded
+options = {"bdist_wheel": {"py_limited_api": "cp312"}} if py_limited_api else {}
+
+
+def is_cibuildwheel() -> bool:
+    return os.getenv("CIBUILDWHEEL") is not None
+
+
+@contextlib.contextmanager
+def _maybe_patch_toolchains() -> Generator[None, None, None]:
+    """
+    Patch rules_python toolchains to ignore root user error
+    when run in a Docker container on Linux in cibuildwheel.
+    """
+
+    def fmt_toolchain_args(matchobj):
+        suffix = "ignore_root_user_error = True"
+        callargs = matchobj.group(1)
+        # toolchain def is broken over multiple lines
+        if callargs.endswith("\n"):
+            callargs = callargs + "    " + suffix + ",\n"
+        # toolchain def is on one line.
+        else:
+            callargs = callargs + ", " + suffix
+        return "python.toolchain(" + callargs + ")"
+
+    CIBW_LINUX = is_cibuildwheel() and platform.system() == "Linux"
+    module_bazel = Path("MODULE.bazel")
+    content: str = module_bazel.read_text()
+    try:
+        if CIBW_LINUX:
+            module_bazel.write_text(
+                re.sub(
+                    r"python.toolchain\(([\w\"\s,.=]*)\)",
+                    fmt_toolchain_args,
+                    content,
+                )
+            )
+        yield
+    finally:
+        if CIBW_LINUX:
+            module_bazel.write_text(content)
+
+
+class BazelExtension(setuptools.Extension):
+    """A C/C++ extension that is defined as a Bazel BUILD target."""
+
+    def __init__(self, name: str, bazel_target: str, **kwargs):
+        super().__init__(name=name, sources=[], **kwargs)
+
+        self.free_threaded = free_threaded
+        self.bazel_target = bazel_target
+        stripped_target = bazel_target.split("//")[-1]
+        self.relpath, self.target_name = stripped_target.split(":")
+
+
+class BuildBazelExtension(build_ext.build_ext):
+    """A command that runs Bazel to build a C/C++ extension."""
+
+    def run(self):
+        for ext in self.extensions:
+            self.bazel_build(ext)
+        # explicitly call `bazel shutdown` for graceful exit
+        self.spawn(["bazel", "shutdown"])
+
+    def copy_extensions_to_source(self):
+        """
+        Copy generated extensions into the source tree.
+        This is done in the ``bazel_build`` method, so it's not necessary to
+        do again in the `build_ext` base class.
+        """
+        pass
+
+    def bazel_build(self, ext: BazelExtension) -> None:
+        """Runs the bazel build to create a nanobind extension."""
+        temp_path = Path(self.build_temp)
+
+        # Specifying only MAJOR.MINOR makes rules_python do an internal
+        # lookup selecting the newest patch version.
+        python_version = "{0}.{1}".format(*sys.version_info[:2])
+
+        bazel_argv = [
+            "bazel",
+            "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 ext.py_limited_api:
+            bazel_argv += ["--py_limited_api=cp312"]
+        if ext.free_threaded:
+            bazel_argv += ["--free_threaded=yes"]
+
+        with _maybe_patch_toolchains():
+            self.spawn(bazel_argv)
+
+        if platform.system() == "Windows":
+            suffix = ".pyd"
+        else:
+            suffix = ".abi3.so" if ext.py_limited_api else ".so"
+
+        # copy the Bazel build artifacts into setuptools' libdir,
+        # from where the wheel is built.
+        srcdir = temp_path / "bazel-bin" / "src"
+        libdir = Path(self.build_lib) / "sip_python"
+        for root, dirs, files in os.walk(srcdir, topdown=True):
+            # exclude runfiles directories and children.
+            dirs[:] = [d for d in dirs if "runfiles" not in d]
+
+            for f in files:
+                fp = Path(f)
+                should_copy = False
+                # we do not want the bare .so file included
+                # when building for ABI3, so we require a
+                # full and exact match on the file extension.
+                if "".join(fp.suffixes) == suffix:
+                    should_copy = True
+                elif fp.suffix == ".pyi":
+                    should_copy = True
+                elif Path(root) == srcdir and f == "py.typed":
+                    # copy py.typed, but only at the package root.
+                    should_copy = True
+
+                if should_copy:
+                    dstdir = libdir / os.path.relpath(root, srcdir)
+                    if not os.path.exists(dstdir):
+                        os.mkdir(dstdir)
+                    shutil.copyfile(root / fp, dstdir / fp)
+
+
+setuptools.setup(
+    cmdclass=dict(build_ext=BuildBazelExtension),
+    package_data={"sip_python": ["py.typed", "*.pyi", "**/*.pyi"]},
+    ext_modules=[
+        BazelExtension(
+            name="sip_python.sip_python_ext",
+            bazel_target="//src:sip_python_ext_stubgen",
+            free_threaded=free_threaded,
+            py_limited_api=py_limited_api,
+        )
+    ],
+    options=options,
+)

sip_python-0.0.1/src/sip_python/__init__.py

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

sip_python-0.0.1/src/sip_python/helpers.py

@@ -0,0 +1,89 @@
+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

sip_python-0.0.1/src/sip_python.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: sip_python
+Version: 0.0.1
+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
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+# sip_python
+[![pip](https://github.com/joaospinto/sip_python/actions/workflows/pip.yml/badge.svg)](https://github.com/joaospinto/sip_python/actions?query=workflow%3Apip)
+[![wheels](https://github.com/joaospinto/sip_python/actions/workflows/wheels.yml/badge.svg)](https://github.com/joaospinto/sip_python/actions?query=workflow%3Awheels)
+
+Python bindings for the [SIP](https://github.com/joaospinto/sip) solver.

sip_python-0.0.1/src/sip_python.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/sip_python/__init__.py
+src/sip_python/helpers.py
+src/sip_python.egg-info/PKG-INFO
+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_nlp.py
+tests/test_simple_qp.py

sip_python-0.0.1/src/sip_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sip_python-0.0.1/src/sip_python.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+scipy

sip_python-0.0.1/src/sip_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+sip_python

sip_python-0.0.1/tests/test_simple_nlp.py

@@ -0,0 +1,148 @@
+from sip_python import (
+    get_kkt_and_L_nnzs,
+    get_kkt_perm_inv,
+    ModelCallbackInput,
+    ModelCallbackOutput,
+    ProblemDimensions,
+    QDLDLSettings,
+    Settings,
+    Solver,
+    Status,
+    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()
+    ss.max_aug_kkt_violation = 1e-12
+    ss.num_iterative_refinement_steps = 1
+    ss.penalty_parameter_increase_factor = 3.0
+    ss.enable_elastics = True
+    ss.elastic_var_cost_coeff = 1e6
+    ss.assert_checks_pass = True
+
+    @jax.jit
+    def f(x):
+        return x[1] * (5.0 + x[0])
+
+    @jax.jit
+    def c(x):
+        return jnp.array([])
+
+    @jax.jit
+    def g(x):
+        return jnp.array(
+            [
+                5.0 - x[0] * x[1],
+                x[0] * x[0] + x[1] * x[1] - 20.0,
+            ]
+        )
+
+    @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)
+
+    x_dim = 2
+
+    mock_x = jnp.ones(
+        [
+            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 = get_kkt_perm_inv(
+        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
+
+    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
+    assert vars.x[0] == pytest.approx(-1.15747396, abs=1e-6)
+    assert vars.x[1] == pytest.approx(-4.31975162, abs=1e-6)

sip_python-0.0.1/tests/test_simple_qp.py

@@ -0,0 +1,145 @@
+from sip_python import (
+    get_kkt_and_L_nnzs,
+    get_kkt_perm_inv,
+    ModelCallbackInput,
+    ModelCallbackOutput,
+    ProblemDimensions,
+    QDLDLSettings,
+    Settings,
+    Solver,
+    Status,
+    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()
+    ss.max_aug_kkt_violation = 1e-12
+    ss.enable_elastics = True
+    ss.elastic_var_cost_coeff = 1e6
+    ss.assert_checks_pass = True
+
+    @jax.jit
+    def f(x):
+        return (
+            0.5 * (4.0 * x[0] * x[0] + 2.0 * x[0] * x[1] + 2.0 * x[1] * x[1])
+            + x[0]
+            + x[1]
+        )
+
+    @jax.jit
+    def c(x):
+        return jnp.array([x[0] + x[1] - 1.0])
+
+    @jax.jit
+    def g(x):
+        return jnp.array([x[0] - 0.7, -x[0] - 0.0, x[1] - 0.7, -x[1] - 0.0])
+
+    @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)
+
+    x_dim = 2
+
+    mock_x = jnp.ones(
+        [
+            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 = get_kkt_perm_inv(
+        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
+
+    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
+    assert vars.x[0] == pytest.approx(0.3, abs=1e-5)
+    assert vars.x[1] == pytest.approx(0.7, abs=1e-5)