qoco 0.1.0__tar.gz

qoco-0.1.0/.github/workflows/build.yml

@@ -0,0 +1,58 @@
+# Taken from osqp-python
+
+name: Build Wheels
+
+on:
+  # Triggers the workflow on push or pull request events
+  push:
+    branches:
+      - "*"
+      - "*/*"
+      - "**"
+  pull_request:
+    branches: [main]
+
+jobs:
+  build_sdist:
+    name: Build source
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@master
+        with:
+          submodules: "recursive"
+
+      - name: Build source and wheel
+        run: |
+          python -m pip install build
+          python -m build --outdir=wheelhouse
+
+      - name: Upload sdist and wheel to github
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: wheelhouse/*
+          if-no-files-found: error
+
+  build_wheels:
+    name: Building wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-13, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - uses: pypa/cibuildwheel@v2.21
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl

qoco-0.1.0/.github/workflows/unit_tests.yml

@@ -0,0 +1,51 @@
+# This is a basic workflow to help you get started with Actions
+
+name: Unit Tests
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events
+  push:
+    branches:
+      - "*"
+      - "*/*"
+      - "**"
+  pull_request:
+    branches: [main]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    strategy:
+      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
+      fail-fast: false
+
+      matrix:
+        os: [ubuntu-latest]
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: >
+          pip install "pybind11[global]" pytest pytest-xdist cvxpy
+
+      - name: Install qoco
+        run: >
+          pip install .
+
+      - name: Run Pytest
+        run: >
+          pytest -n 12

qoco-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+*.egg-info/
+build/
+.vscode/
+__pycache__/
+qoco_custom*/

qoco-0.1.0/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.15)
+project(extension)
+
+set(CMAKE_CXX_STANDARD 11)
+
+set(QOCO_BUILD_TYPE "Release")
+
+# Detect operating system.
+message(STATUS "We are on a ${CMAKE_SYSTEM_NAME} system")
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    add_compile_definitions(IS_LINUX)
+elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+    add_compile_definitions(IS_MACOS)
+endif()
+
+find_package(pybind11 REQUIRED)
+
+message(STATUS "Fetching/configuring QOCO")
+list(APPEND CMAKE_MESSAGE_INDENT "  ")
+include(FetchContent)
+FetchContent_Declare(
+  qoco
+  GIT_REPOSITORY https://github.com/qoco-org/qoco.git
+  GIT_TAG 5abc44574b62e5a28cdae8e97ea70ecacf1f954c
+)
+
+list(POP_BACK CMAKE_MESSAGE_INDENT)
+FetchContent_MakeAvailable(qoco)
+
+pybind11_add_module(qoco_ext src/bindings.cpp)
+target_include_directories(qoco_ext INTERFACE ${qoco_SOURCE_DIR}/include)
+target_link_libraries(qoco_ext PUBLIC pybind11::module qocostatic)
+install(TARGETS qoco_ext DESTINATION . COMPONENT python)

qoco-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Govind Chari
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

qoco-0.1.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.1
+Name: qoco
+Version: 0.1.0
+Summary: QOCO: Quadratic Objective Conic Optimizer
+Author-Email: "Govind M. Chari" <govindchari1@gmail.com>
+Project-URL: Homepage, https://github.com/qoco-org/qoco
+Project-URL: Issues, https://github.com/qoco-org/qoco/issues
+Requires-Python: >=3.8
+Requires-Dist: jinja2
+Requires-Dist: numpy>=1.7
+Requires-Dist: qdldl
+Requires-Dist: scipy>=0.13.2
+Requires-Dist: setuptools
+Description-Content-Type: text/markdown
+
+# QOCO Python
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/7bd44fa7-d198-4739-bb79-a5c15e04a8de" alt="drawing" width="500"/>
+</p>
+
+<p align="center">
+  <a href="https://opensource.org/licenses/BSD-3-Clause"><img src="https://img.shields.io/badge/License-BSD_3--Clause-blue.svg" alt="License" /></a>
+  <a href=https://github.com/qoco-org/qoco-python/actions/workflows/unit_tests.yml/badge.svg"><img src="https://github.com/qoco-org/qoco-python/actions/workflows/unit_tests.yml/badge.svg"/></a>
+</p>
+
+This repository contains the python wrapper for [QOCO](https://github.com/qoco-org/qoco) and the code generator QOCOGEN.
+
+QOCOGEN is a code generator which takes in an second-order cone program problem family and generates a customized C solver (called qoco_custom) for the specified problem family which implements the same algorithm as QOCO. This customized solver is library-free, only uses static memory allocation, and can be a few times faster than QOCO.
+
+## Bug reports
+
+File any issues or bug reports using the [issue tracker](https://github.com/qoco-org/qoco-python/issues).
+
+## Citing
+```
+ @misc{chari2025qoco,
+    author = {Chari, Govind M. and Acikmese, Behcet},
+    title = {QOCO},
+    year = {2025},
+    publisher = {GitHub},
+    journal = {GitHub repository},
+    howpublished = {\url{https://github.com/qoco-org/qoco}},
+ }
+```
+
+## License
+QOCO is licensed under the BSD-3-Clause license.

qoco-0.1.0/README.md

@@ -0,0 +1,32 @@
+# QOCO Python
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/7bd44fa7-d198-4739-bb79-a5c15e04a8de" alt="drawing" width="500"/>
+</p>
+
+<p align="center">
+  <a href="https://opensource.org/licenses/BSD-3-Clause"><img src="https://img.shields.io/badge/License-BSD_3--Clause-blue.svg" alt="License" /></a>
+  <a href=https://github.com/qoco-org/qoco-python/actions/workflows/unit_tests.yml/badge.svg"><img src="https://github.com/qoco-org/qoco-python/actions/workflows/unit_tests.yml/badge.svg"/></a>
+</p>
+
+This repository contains the python wrapper for [QOCO](https://github.com/qoco-org/qoco) and the code generator QOCOGEN.
+
+QOCOGEN is a code generator which takes in an second-order cone program problem family and generates a customized C solver (called qoco_custom) for the specified problem family which implements the same algorithm as QOCO. This customized solver is library-free, only uses static memory allocation, and can be a few times faster than QOCO.
+
+## Bug reports
+
+File any issues or bug reports using the [issue tracker](https://github.com/qoco-org/qoco-python/issues).
+
+## Citing
+```
+ @misc{chari2025qoco,
+    author = {Chari, Govind M. and Acikmese, Behcet},
+    title = {QOCO},
+    year = {2025},
+    publisher = {GitHub},
+    journal = {GitHub repository},
+    howpublished = {\url{https://github.com/qoco-org/qoco}},
+ }
+```
+
+## License
+QOCO is licensed under the BSD-3-Clause license.

qoco-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["scikit-build-core", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "qoco"
+version = "0.1.0"
+description = "QOCO: Quadratic Objective Conic Optimizer"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [{ name = "Govind M. Chari", email = "govindchari1@gmail.com" }]
+dependencies = ["jinja2", "numpy>=1.7", "qdldl", "scipy>=0.13.2", "setuptools"]
+
+[tool.scikit-build]
+install.components = ["python"]
+wheel.install-dir = "qoco"
+
+[project.urls]
+Homepage = "https://github.com/qoco-org/qoco"
+Issues = "https://github.com/qoco-org/qoco/issues"

qoco-0.1.0/requirements.txt

@@ -0,0 +1,7 @@
+pybind11
+numpy>=1.7
+# Exclude scipy 1.12 because the random sparse array function started returning
+# the transpose of the original, breaking the unit tests. This was fixed in 1.13.0.
+# ref: https://github.com/scipy/scipy/issues/20027
+scipy>=0.13.2,!=1.12.0
+qdldl

qoco-0.1.0/src/bindings.cpp

@@ -0,0 +1,313 @@
+/* Copyright (c) 2024, Govind M. Chari <govindchari1@gmail.com> */
+/* This source code is licensed under the BSD 3-Clause License  */
+
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include "qoco.h"
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+class CSC
+{
+public:
+    CSC(py::object A);
+    ~CSC();
+    QOCOCscMatrix *getcsc() const;
+    py::array_t<QOCOFloat> _x;
+    py::array_t<QOCOInt> _i;
+    py::array_t<QOCOInt> _p;
+    QOCOInt m;
+    QOCOInt n;
+    QOCOInt nnz;
+
+private:
+    QOCOCscMatrix *_csc;
+};
+
+CSC::CSC(py::object A)
+{
+    py::object spa = py::module::import("scipy.sparse");
+
+    if (A == py::none())
+    {
+        this->m = 0;
+        this->n = 0;
+        this->nnz = 0;
+        this->_csc = nullptr;
+    }
+
+    else
+    {
+        py::tuple dim = A.attr("shape");
+
+        int m = dim[0].cast<int>();
+        int n = dim[1].cast<int>();
+
+        if (!spa.attr("isspmatrix_csc")(A))
+        {
+            A = spa.attr("csc_matrix")(A);
+        }
+
+        this->_p = A.attr("indptr").cast<py::array_t<QOCOInt, py::array::c_style>>();
+        this->_i = A.attr("indices").cast<py::array_t<QOCOInt, py::array::c_style>>();
+        this->_x = A.attr("data").cast<py::array_t<QOCOFloat, py::array::c_style>>();
+
+        this->_csc = new QOCOCscMatrix();
+        this->_csc->m = m;
+        this->_csc->n = n;
+        this->_csc->x = (QOCOFloat *)this->_x.data();
+        this->_csc->i = (QOCOInt *)this->_i.data();
+        this->_csc->p = (QOCOInt *)this->_p.data();
+        this->_csc->nnz = A.attr("nnz").cast<int>();
+
+        this->m = this->_csc->m;
+        this->n = this->_csc->n;
+        this->nnz = this->_csc->nnz;
+    }
+}
+
+QOCOCscMatrix *CSC::getcsc() const
+{
+    return this->_csc;
+}
+
+CSC::~CSC()
+{
+    if (this->_csc)
+        delete this->_csc;
+}
+
+class PyQOCOSolution
+{
+public:
+    PyQOCOSolution(QOCOSolution &, QOCOInt, QOCOInt, QOCOInt);
+    py::array_t<QOCOFloat> get_x();
+    py::array_t<QOCOFloat> get_s();
+    py::array_t<QOCOFloat> get_y();
+    py::array_t<QOCOFloat> get_z();
+    QOCOSolution &_solution;
+
+private:
+    QOCOInt _n;
+    QOCOInt _m;
+    QOCOInt _p;
+};
+
+PyQOCOSolution::PyQOCOSolution(QOCOSolution &solution, QOCOInt n, QOCOInt m, QOCOInt p) : _n(n), _m(m), _p(p), _solution(solution)
+{
+}
+
+py::array_t<QOCOFloat> PyQOCOSolution::get_x()
+{
+    return py::array_t<QOCOFloat>(
+        {this->_n},
+        {sizeof(QOCOFloat)},
+        this->_solution.x);
+}
+
+py::array_t<QOCOFloat> PyQOCOSolution::get_s()
+{
+    return py::array_t<QOCOFloat>(
+        {this->_m},
+        {sizeof(QOCOFloat)},
+        this->_solution.s);
+}
+
+py::array_t<QOCOFloat> PyQOCOSolution::get_y()
+{
+    return py::array_t<QOCOFloat>(
+        {this->_p},
+        {sizeof(QOCOFloat)},
+        this->_solution.y);
+}
+
+py::array_t<QOCOFloat> PyQOCOSolution::get_z()
+{
+    return py::array_t<QOCOFloat>(
+        {this->_m},
+        {sizeof(QOCOFloat)},
+        this->_solution.z);
+}
+
+class PyQOCOSolver
+{
+public:
+    PyQOCOSolver(QOCOInt, QOCOInt, QOCOInt, const CSC &, const py::array_t<QOCOFloat>, const CSC &, const py::array_t<QOCOFloat>, const CSC &, const py::array_t<QOCOFloat>, QOCOInt, QOCOInt, const py::array_t<QOCOInt>, QOCOSettings *);
+    ~PyQOCOSolver();
+
+    QOCOSettings *get_settings();
+    PyQOCOSolution &get_solution();
+
+    QOCOInt update_settings(const QOCOSettings &);
+    // QOCOInt update_vector_data(py::object, py::object, py::object);
+    // QOCOInt update_matrix_data(py::object, py::object, py::object);
+
+    QOCOInt solve();
+
+private:
+    QOCOInt n;
+    QOCOInt m;
+    QOCOInt p;
+
+    const CSC &_P;
+    py::array_t<QOCOFloat> _c;
+
+    const CSC &_A;
+    py::array_t<QOCOFloat> _b;
+
+    const CSC &_G;
+    py::array_t<QOCOFloat> _h;
+
+    QOCOInt l;
+    QOCOInt nsoc;
+    py::array_t<QOCOInt> _q;
+
+    QOCOSolver *_solver;
+};
+
+PyQOCOSolver::PyQOCOSolver(QOCOInt n, QOCOInt m, QOCOInt p, const CSC &P, const py::array_t<QOCOFloat> c, const CSC &A, const py::array_t<QOCOFloat> b, const CSC &G, const py::array_t<QOCOFloat> h, QOCOInt l, QOCOInt nsoc, const py::array_t<QOCOInt> q, QOCOSettings *settings) : n(n), m(m), p(p), _P(P), _c(c), _A(A), _b(b), _G(G), _h(h), l(l), nsoc(nsoc), _q(q)
+{
+    this->_solver = new QOCOSolver();
+
+    py::tuple dim = this->_b.attr("shape");
+    QOCOFloat *bptr;
+    if (dim[0].cast<int>() == 0)
+    {
+        bptr = (QOCOFloat *)nullptr;
+    }
+    else
+    {
+        bptr = (QOCOFloat *)this->_b.data();
+    }
+
+    dim = this->_h.attr("shape");
+    QOCOFloat *hptr;
+    if (dim[0].cast<int>() == 0)
+    {
+        hptr = nullptr;
+    }
+    else
+    {
+        hptr = (QOCOFloat *)this->_h.data();
+    }
+
+    dim = this->_q.attr("shape");
+    QOCOInt *qptr;
+    if (dim[0].cast<int>() == 0)
+    {
+        qptr = nullptr;
+    }
+    else
+    {
+        qptr = (QOCOInt *)this->_q.data();
+    }
+
+    QOCOInt status = qoco_setup(this->_solver, n, m, p, this->_P.getcsc(), (QOCOFloat *)this->_c.data(), this->_A.getcsc(), bptr, this->_G.getcsc(), hptr, l, nsoc, qptr, settings);
+
+    if (status)
+    {
+        std::string message = "Setup Error (Error Code " + std::to_string(status) + ")";
+        throw py::value_error(message);
+    }
+}
+
+PyQOCOSolver::~PyQOCOSolver()
+{
+    qoco_cleanup(this->_solver);
+}
+
+QOCOSettings *PyQOCOSolver::get_settings()
+{
+    return this->_solver->settings;
+}
+
+PyQOCOSolution &PyQOCOSolver::get_solution()
+{
+    PyQOCOSolution *solution = new PyQOCOSolution(*this->_solver->sol, this->n, this->m, this->p);
+    return *solution;
+}
+
+QOCOInt PyQOCOSolver::solve()
+{
+    py::gil_scoped_release release;
+    QOCOInt status = qoco_solve(this->_solver);
+    py::gil_scoped_acquire acquire;
+    return status;
+}
+
+QOCOInt PyQOCOSolver::update_settings(const QOCOSettings &new_settings)
+{
+    return qoco_update_settings(this->_solver, &new_settings);
+}
+
+PYBIND11_MODULE(qoco_ext, m)
+{
+    // Enums.
+    py::enum_<qoco_solve_status>(m, "qoco_solve_status", py::module_local())
+        .value("QOCO_UNSOLVED", QOCO_UNSOLVED)
+        .value("QOCO_SOLVED", QOCO_SOLVED)
+        .value("QOCO_SOLVED_INACCURATE", QOCO_SOLVED_INACCURATE)
+        .value("QOCO_MAX_ITER", QOCO_MAX_ITER)
+        .value("QOCO_NUMERICAL_ERROR", QOCO_NUMERICAL_ERROR)
+        .export_values();
+
+    // CSC.
+    py::class_<CSC>(m, "CSC", py::module_local())
+        .def(py::init<py::object>())
+        .def_readonly("m", &CSC::m)
+        .def_readonly("n", &CSC::n)
+        .def_readonly("x", &CSC::_x)
+        .def_readonly("i", &CSC::_i)
+        .def_readonly("p", &CSC::_p)
+        .def_readonly("nnz", &CSC::nnz);
+
+    // Settings.
+    py::class_<QOCOSettings>(m, "QOCOSettings", py::module_local())
+        .def(py::init([]()
+                      { return new QOCOSettings(); }))
+        .def_readwrite("max_iters", &QOCOSettings::max_iters)
+        .def_readwrite("bisect_iters", &QOCOSettings::bisect_iters)
+        .def_readwrite("ruiz_iters", &QOCOSettings::ruiz_iters)
+        .def_readwrite("iter_ref_iters", &QOCOSettings::iter_ref_iters)
+        .def_readwrite("abstol", &QOCOSettings::abstol)
+        .def_readwrite("reltol", &QOCOSettings::reltol)
+        .def_readwrite("abstol_inacc", &QOCOSettings::abstol_inacc)
+        .def_readwrite("reltol_inacc", &QOCOSettings::reltol_inacc)
+        .def_readwrite("kkt_static_reg", &QOCOSettings::kkt_static_reg)
+        .def_readwrite("kkt_dynamic_reg", &QOCOSettings::kkt_dynamic_reg)
+        .def_readwrite("verbose", &QOCOSettings::verbose);
+
+    m.def("set_default_settings", &set_default_settings);
+
+    // Solution.
+    py::class_<PyQOCOSolution>(m, "QOCOSolution", py::module_local())
+        .def_property_readonly("x", &PyQOCOSolution::get_x)
+        .def_property_readonly("s", &PyQOCOSolution::get_s)
+        .def_property_readonly("y", &PyQOCOSolution::get_y)
+        .def_property_readonly("z", &PyQOCOSolution::get_z)
+        .def_property_readonly("iters", [](const PyQOCOSolution &sol)
+                               { return sol._solution.iters; })
+        .def_property_readonly("setup_time_sec", [](const PyQOCOSolution &sol)
+                               { return sol._solution.setup_time_sec; })
+        .def_property_readonly("solve_time_sec", [](const PyQOCOSolution &sol)
+                               { return sol._solution.solve_time_sec; })
+        .def_property_readonly("obj", [](const PyQOCOSolution &sol)
+                               { return sol._solution.obj; })
+        .def_property_readonly("pres", [](const PyQOCOSolution &sol)
+                               { return sol._solution.pres; })
+        .def_property_readonly("dres", [](const PyQOCOSolution &sol)
+                               { return sol._solution.dres; })
+        .def_property_readonly("gap", [](const PyQOCOSolution &sol)
+                               { return sol._solution.gap; })
+        .def_property_readonly("status", [](const PyQOCOSolution &sol)
+                               { return sol._solution.status; });
+
+    // Solver.
+    py::class_<PyQOCOSolver>(m, "QOCOSolver", py::module_local())
+        .def(py::init<QOCOInt, QOCOInt, QOCOInt, const CSC &, const py::array_t<QOCOFloat>, const CSC &, const py::array_t<QOCOFloat>, const CSC &, const py::array_t<QOCOFloat>, QOCOInt, QOCOInt, const py::array_t<QOCOInt>, QOCOSettings *>(), "n"_a, "m"_a, "p"_a, "P"_a, "c"_a.noconvert(), "A"_a, "b"_a.noconvert(), "G"_a, "h"_a.noconvert(), "l"_a, "nsoc"_a, "q"_a.noconvert(), "settings"_a)
+        .def_property_readonly("solution", &PyQOCOSolver::get_solution, py::return_value_policy::reference)
+        .def("update_settings", &PyQOCOSolver::update_settings)
+        .def("solve", &PyQOCOSolver::solve)
+        .def("get_settings", &PyQOCOSolver::get_settings, py::return_value_policy::reference);
+}

qoco-0.1.0/src/qoco/__init__.py

@@ -0,0 +1 @@
+from qoco.interface import QOCO