pyqpmad 1.4.0__tar.gz

pyqpmad-1.4.0/.github/workflows/wheels.yml

@@ -0,0 +1,60 @@
+name: Wheel and sdist build
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@ee02a1537ce3071a004a6b08c41e72f0fdc42d9a # v3.4.0
+
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  upload_pypi:
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

pyqpmad-1.4.0/.gitignore

@@ -0,0 +1,19 @@
+build*/
+install*/
+.pytest_cache/
+.cache/
+.pixi/
+__pycache__/
+Xcode*
+*.pyc
+*~
+*.egg-info
+.ruff_cache/
+.DS_Store
+compile_commands.json
+cmake-profiling.json
+result
+*.conda
+dist/
+.venv/
+wheelhouse/

pyqpmad-1.4.0/CMakeLists.txt

@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.22)
+project(pyqpmad)
+
+find_package(Python 3.10 REQUIRED COMPONENTS Interpreter Development.Module)
+
+include(FetchContent)
+FetchContent_Declare(
+    nanobind
+    GIT_REPOSITORY https://github.com/wjakob/nanobind.git
+    GIT_TAG v2.12.0
+)
+FetchContent_MakeAvailable(nanobind)
+
+FetchContent_Declare(
+    eigen
+    GIT_REPOSITORY https://github.com/eigen-mirror/eigen.git
+    GIT_TAG 5.0.1
+)
+FetchContent_MakeAvailable(eigen)
+
+FetchContent_Declare(
+    qpmad
+    GIT_REPOSITORY https://github.com/asherikov/qpmad.git
+    GIT_TAG 1.4.0
+    SOURCE_SUBDIR
+    download_only
+)
+FetchContent_MakeAvailable(qpmad)
+file(
+    GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/generated/include/qpmad/config.h
+    CONTENT
+        "#pragma once
+// #define QPMAD_ENABLE_TRACING
+// #define QPMAD_USE_HOUSEHOLDER
+// #define QPMAD_PEDANTIC_LICENSE
+"
+)
+add_library(qpmad INTERFACE IMPORTED)
+target_include_directories(
+    qpmad
+    INTERFACE
+        ${qpmad_SOURCE_DIR}/include
+        ${CMAKE_CURRENT_BINARY_DIR}/generated/include
+        ${CMAKE_CURRENT_BINARY_DIR}/generated/include/qpmad
+)
+target_link_libraries(qpmad INTERFACE Eigen3::Eigen)
+
+nanobind_add_module(pyqpmad 
+    NB_STATIC STABLE_ABI LTO
+    qpmad_pywrap.cpp
+)
+nanobind_add_stub(
+    pyqpmad_stub
+    MODULE pyqpmad
+    OUTPUT pyqpmad.pyi
+    PYTHON_PATH $<TARGET_FILE_DIR:pyqpmad>
+    DEPENDS pyqpmad
+)
+
+target_link_libraries(pyqpmad PRIVATE qpmad)
+
+install(TARGETS pyqpmad DESTINATION .)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pyqpmad.pyi DESTINATION .)

pyqpmad-1.4.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.2
+Name: pyqpmad
+Version: 1.4.0
+Summary: Python wrapper for qpmad
+Requires-Python: >=3.10
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-benchmark; extra == "test"
+Requires-Dist: numpy; extra == "test"
+Description-Content-Type: text/markdown
+
+# pyqpmad
+
+A fast Python wrapper for [qpmad](https://github.com/asherikov/qpmad), a C++ Quadratic Programming (QP) solver based on Goldfarb-Idnani's active-set method. 
+`pyqpmad` is built using [nanobind](https://github.com/wjakob/nanobind) for high-performance Python bindings and [Eigen](https://eigen.tuxfamily.org/) for efficient linear algebra.
+
+## Features
+
+- Solves Unconstrained, Constrained, and Bounded Quadratic Programs.
+- Lightweight and fast wrapper utilizing `nanobind`.
+- Automatic compilation of dependencies (`qpmad`, `eigen`, `nanobind`) from source via CMake.
+
+## Installation
+
+### Using `uv` (Recommended)
+
+You can easily build and install this package using [`uv`](https://github.com/astral-sh/uv), an extremely fast Python package installer and resolver.
+
+To install it directly:
+```bash
+uv pip install .
+```
+
+To run the tests:
+```bash
+uv run --with pytest  test_qpmad.py
+```
+
+### Using `pip`
+
+```bash
+pip install .
+```
+
+To run tests with pip:
+```bash
+pip install pytest
+pytest test_qpmad.py
+```
+
+## Build Explanation
+
+The build process is managed entirely by CMake. When you install the package (via `pip` or `uv`), CMake's `FetchContent` module is triggered to automatically download the required dependencies:
+- **`nanobind`** (v2.12.0)
+- **`eigen`** (v5.0.1 mirror)
+- **`qpmad`** (v1.4.0)
+
+CMake then configures `qpmad` as an interface library linked with Eigen, and compiles the Python wrapper (`qpmad_pywrap.cpp`) using `nanobind`. Finally, Python type stubs (`.pyi`) are generated for IDE type hinting.
+
+## Example Usage
+
+Here is a quick example demonstrating how to solve a constrained QP problem.
+
+**Problem:** Minimize $x^2 + y^2$ subject to $x + y = 1$
+
+```python
+import pyqpmad
+import numpy as np
+
+solver = pyqpmad.Solver()
+
+# Define the Hessian matrix (H) and linear term (h)
+H = np.array([[2.0, 0.0], 
+              [0.0, 2.0]], order='F')
+h = np.array([0.0, 0.0])
+
+# Define the linear constraint: 1.0 <= x + y <= 1.0
+A = np.array([[1.0, 1.0]], order='F')
+Alb = np.array([1.0]) # Lower bound
+Aub = np.array([1.0]) # Upper bound
+
+# Pre-allocate output array
+primal = np.zeros(2)
+
+# Solve
+status = solver.solve(primal, H, h, A=A, Alb=Alb, Aub=Aub)
+
+if status == pyqpmad.ReturnStatus.OK:
+    print(f"Optimal solution found: {primal}") # Output: [0.5 0.5]
+else:
+    print(f"Failed to solve. Status: {status}")
+```
+
+For more examples—such as solving unconstrained problems or adding lower/upper bounds—please check `test_qpmad.py`.
+
+## Release Pipeline
+
+This project uses `cibuildwheel` integrated via GitHub Actions to automatically build wheels for Linux, macOS, and Windows.
+
+### Triggering a Release
+
+To publish a new release to PyPI, tag the main branch with a version number starting with `v` (e.g., `v1.0.0`) and push the tag to GitHub:
+
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+
+The GitHub Actions workflow will:
+1. Build `sdist` and wheels for all major platforms.
+2. Run tests on the generated wheels.
+3. Automatically publish the artifacts to PyPI.

pyqpmad-1.4.0/README.md

@@ -0,0 +1,101 @@
+# pyqpmad
+
+A fast Python wrapper for [qpmad](https://github.com/asherikov/qpmad), a C++ Quadratic Programming (QP) solver based on Goldfarb-Idnani's active-set method. 
+`pyqpmad` is built using [nanobind](https://github.com/wjakob/nanobind) for high-performance Python bindings and [Eigen](https://eigen.tuxfamily.org/) for efficient linear algebra.
+
+## Features
+
+- Solves Unconstrained, Constrained, and Bounded Quadratic Programs.
+- Lightweight and fast wrapper utilizing `nanobind`.
+- Automatic compilation of dependencies (`qpmad`, `eigen`, `nanobind`) from source via CMake.
+
+## Installation
+
+### Using `uv` (Recommended)
+
+You can easily build and install this package using [`uv`](https://github.com/astral-sh/uv), an extremely fast Python package installer and resolver.
+
+To install it directly:
+```bash
+uv pip install .
+```
+
+To run the tests:
+```bash
+uv run --with pytest  test_qpmad.py
+```
+
+### Using `pip`
+
+```bash
+pip install .
+```
+
+To run tests with pip:
+```bash
+pip install pytest
+pytest test_qpmad.py
+```
+
+## Build Explanation
+
+The build process is managed entirely by CMake. When you install the package (via `pip` or `uv`), CMake's `FetchContent` module is triggered to automatically download the required dependencies:
+- **`nanobind`** (v2.12.0)
+- **`eigen`** (v5.0.1 mirror)
+- **`qpmad`** (v1.4.0)
+
+CMake then configures `qpmad` as an interface library linked with Eigen, and compiles the Python wrapper (`qpmad_pywrap.cpp`) using `nanobind`. Finally, Python type stubs (`.pyi`) are generated for IDE type hinting.
+
+## Example Usage
+
+Here is a quick example demonstrating how to solve a constrained QP problem.
+
+**Problem:** Minimize $x^2 + y^2$ subject to $x + y = 1$
+
+```python
+import pyqpmad
+import numpy as np
+
+solver = pyqpmad.Solver()
+
+# Define the Hessian matrix (H) and linear term (h)
+H = np.array([[2.0, 0.0], 
+              [0.0, 2.0]], order='F')
+h = np.array([0.0, 0.0])
+
+# Define the linear constraint: 1.0 <= x + y <= 1.0
+A = np.array([[1.0, 1.0]], order='F')
+Alb = np.array([1.0]) # Lower bound
+Aub = np.array([1.0]) # Upper bound
+
+# Pre-allocate output array
+primal = np.zeros(2)
+
+# Solve
+status = solver.solve(primal, H, h, A=A, Alb=Alb, Aub=Aub)
+
+if status == pyqpmad.ReturnStatus.OK:
+    print(f"Optimal solution found: {primal}") # Output: [0.5 0.5]
+else:
+    print(f"Failed to solve. Status: {status}")
+```
+
+For more examples—such as solving unconstrained problems or adding lower/upper bounds—please check `test_qpmad.py`.
+
+## Release Pipeline
+
+This project uses `cibuildwheel` integrated via GitHub Actions to automatically build wheels for Linux, macOS, and Windows.
+
+### Triggering a Release
+
+To publish a new release to PyPI, tag the main branch with a version number starting with `v` (e.g., `v1.0.0`) and push the tag to GitHub:
+
+```bash
+git tag v1.0.0
+git push origin v1.0.0
+```
+
+The GitHub Actions workflow will:
+1. Build `sdist` and wheels for all major platforms.
+2. Run tests on the generated wheels.
+3. Automatically publish the artifacts to PyPI.

pyqpmad-1.4.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "pyqpmad"
+version = "1.4.0"
+description = "Python wrapper for qpmad"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-benchmark", "numpy"]
+
+[build-system]
+requires = ["scikit-build-core>=0.8.0"]
+build-backend = "scikit_build_core.build"
+
+[tool.scikit-build]
+cmake.version = ">=3.22"
+ninja.version = ">=1.5"
+
+[tool.cibuildwheel]
+test-command = "pytest {project}/test_qpmad.py"
+test-requires = ["pytest", "pytest-benchmark", "numpy"]
+
+# Build for standard CPython only, skipping 32-bit builds
+build = "cp3*"
+skip = "*-win32 *_i686"

pyqpmad-1.4.0/qpmad_pywrap.cpp

@@ -0,0 +1,65 @@
+#include <nanobind/eigen/dense.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <qpmad/solver.h>
+
+namespace nb = nanobind;
+
+NB_MODULE(pyqpmad, m) {
+  nb::enum_<qpmad::SolverParameters::HessianType>(m, "HessianType")
+      .value("UNDEFINED", qpmad::SolverParameters::UNDEFINED)
+      .value("HESSIAN_LOWER_TRIANGULAR",
+             qpmad::SolverParameters::HESSIAN_LOWER_TRIANGULAR)
+      .value("HESSIAN_CHOLESKY_FACTOR",
+             qpmad::SolverParameters::HESSIAN_CHOLESKY_FACTOR)
+      .value("HESSIAN_INVERTED_CHOLESKY_FACTOR",
+             qpmad::SolverParameters::HESSIAN_INVERTED_CHOLESKY_FACTOR)
+      .export_values();
+
+  nb::class_<qpmad::SolverParameters>(m, "SolverParameters")
+      .def(nb::init<>())
+      .def_rw("hessian_type", &qpmad::SolverParameters::hessian_type_)
+      .def_rw("tolerance", &qpmad::SolverParameters::tolerance_)
+      .def_rw("max_iter", &qpmad::SolverParameters::max_iter_)
+      .def_rw("return_inverted_cholesky_factor",
+              &qpmad::SolverParameters::return_inverted_cholesky_factor_);
+
+  nb::enum_<qpmad::Solver::ReturnStatus>(m, "ReturnStatus")
+      .value("OK", qpmad::Solver::OK)
+      .value("MAXIMAL_NUMBER_OF_ITERATIONS",
+             qpmad::Solver::MAXIMAL_NUMBER_OF_ITERATIONS)
+      .value("UNDEFINED", qpmad::Solver::UNDEFINED)
+      .export_values();
+
+  nb::class_<qpmad::Solver>(m, "Solver")
+      .def(nb::init<>())
+      .def("reserve", &qpmad::Solver::reserve, nb::arg("primal_size"),
+           nb::arg("num_simple_bounds"), nb::arg("num_general_constraints"))
+      .def(
+          "solve",
+          [](qpmad::Solver &s, Eigen::Ref<Eigen::VectorXd> primal,
+             Eigen::MatrixXd H, const Eigen::Ref<const Eigen::VectorXd> &h,
+             const std::optional<Eigen::Ref<const Eigen::VectorXd>> &lb,
+             const std::optional<Eigen::Ref<const Eigen::VectorXd>> &ub,
+             const std::optional<Eigen::Ref<const Eigen::MatrixXd>> &A,
+             const std::optional<Eigen::Ref<const Eigen::VectorXd>> &Alb,
+             const std::optional<Eigen::Ref<const Eigen::VectorXd>> &Aub,
+             const std::optional<qpmad::SolverParameters> &params) {
+            Eigen::VectorXd ev;
+            Eigen::MatrixXd em;
+            qpmad::SolverParameters default_params;
+            const qpmad::SolverParameters &params_ref =
+                params ? *params : default_params;
+
+            return s.solve(
+                primal, H, h, lb ? *lb : (Eigen::Ref<const Eigen::VectorXd>)ev,
+                ub ? *ub : (Eigen::Ref<const Eigen::VectorXd>)ev,
+                A ? *A : (Eigen::Ref<const Eigen::MatrixXd>)em,
+                Alb ? *Alb : (Eigen::Ref<const Eigen::VectorXd>)ev,
+                Aub ? *Aub : (Eigen::Ref<const Eigen::VectorXd>)ev, params_ref);
+          },
+          nb::arg("primal").noconvert(), nb::arg("H"), nb::arg("h"),
+          nb::arg("lb") = nb::none(), nb::arg("ub") = nb::none(),
+          nb::arg("A") = nb::none(), nb::arg("Alb") = nb::none(),
+          nb::arg("Aub") = nb::none(), nb::arg("params") = nb::none());
+}

pyqpmad-1.4.0/test_qpmad.py

@@ -0,0 +1,101 @@
+import pyqpmad
+import numpy as np
+import pytest
+
+def test_unconstrained():
+    solver = pyqpmad.Solver()
+    H = np.array([[2.0, 0.0], [0.0, 2.0]], order='F')
+    h = np.array([-2.0, -4.0])
+    primal = np.zeros(2)
+    
+    # Minimize 1/2 x'Hx + h'x  =>  x'x + [-2, -4]'x
+    # Gradient: 2x + [-2, -4]' = 0  => x = [1, 2]
+    
+    status = solver.solve(primal, H, h)
+    
+    assert status == pyqpmad.ReturnStatus.OK
+    np.testing.assert_allclose(primal, [1.0, 2.0])
+
+def test_constrained():
+    solver = pyqpmad.Solver()
+    # Minimize x^2 + y^2 subject to x + y = 1
+    H = np.array([[2.0, 0.0], [0.0, 2.0]], order='F')
+    h = np.array([0.0, 0.0])
+    A = np.array([[1.0, 1.0]], order='F')
+    Alb = np.array([1.0])
+    Aub = np.array([1.0])
+    primal = np.zeros(2)
+    
+    status = solver.solve(primal, H, h, A=A, Alb=Alb, Aub=Aub)
+    
+    assert status == pyqpmad.ReturnStatus.OK
+    # Optimum is at x=0.5, y=0.5
+    np.testing.assert_allclose(primal, [0.5, 0.5])
+
+def test_bounds():
+    solver = pyqpmad.Solver()
+    # Minimize x^2 + y^2 subject to x >= 1, y >= 1
+    H = np.array([[2.0, 0.0], [0.0, 2.0]], order='F')
+    h = np.array([0.0, 0.0])
+    lb = np.array([1.0, 1.0])
+    ub = np.array([10.0, 10.0])
+    primal = np.zeros(2)
+    
+    status = solver.solve(primal, H, h, lb=lb, ub=ub)
+    
+    assert status == pyqpmad.ReturnStatus.OK
+    np.testing.assert_allclose(primal, [1.0, 1.0])
+
+@pytest.mark.parametrize("size", [4, 10, 50, 100, 500])
+def test_random_problems(size):
+    np.random.seed(42)
+    solver = pyqpmad.Solver()
+    
+    # Generate random positive definite Hessian
+    Q, _ = np.linalg.qr(np.random.randn(size, size))
+    D = np.diag(np.random.rand(size) + 0.1)
+    H = (Q @ D @ Q.T)
+    
+    # Random linear part
+    h = np.random.randn(size)
+    
+    # 1. Unconstrained
+    primal = np.zeros(size)
+    status = solver.solve(primal, H, h)
+    assert status == pyqpmad.ReturnStatus.OK
+    # Reference solution: x = -H^-1 h
+    ref_sol = np.linalg.solve(H, -h)
+    np.testing.assert_allclose(primal, ref_sol, atol=1e-8)
+    
+    # 2. Bounded
+    # Add tight bounds around a random point
+    target = np.random.randn(size)
+    lb = target - 0.1
+    ub = target + 0.1
+    primal = np.zeros(size)
+    status = solver.solve(primal, H, h, lb=lb, ub=ub)
+    assert status == pyqpmad.ReturnStatus.OK
+    # Check if bounds are satisfied
+    assert np.all(primal >= lb - 1e-10)
+    assert np.all(primal <= ub + 1e-10)
+
+    # 3. Constrained
+    # Add random linear constraints
+    n_cons = size // 2 if size > 2 else 1
+    A = np.random.randn(n_cons, size)
+    # Make constraints feasible by picking a point and calculating bounds
+    x_feat = np.random.randn(size)
+    Ax_feat = A @ x_feat
+    Alb = Ax_feat - 0.1
+    Aub = Ax_feat + 0.1
+    
+    primal = np.zeros(size)
+    status = solver.solve(primal, H, h, A=A, Alb=Alb, Aub=Aub)
+    assert status == pyqpmad.ReturnStatus.OK
+    # Check if constraints are satisfied
+    Ax = A @ primal
+    assert np.all(Ax >= Alb - 1e-10)
+    assert np.all(Ax <= Aub + 1e-10)
+
+if __name__ == "__main__":
+    pytest.main([__file__])