fastprox 0.1.0rc1__tar.gz

fastprox-0.1.0rc1/.github/workflows/bench.yml

@@ -0,0 +1,52 @@
+name: bench
+
+# Benchmarks on GitHub's Linux runners: homogeneous cores (unlike a laptop
+# with performance and efficiency cores), but shared VMs, so compare solvers
+# within one run rather than across runs. Started by hand from the Actions tab.
+on:
+  workflow_dispatch:
+    inputs:
+      full:
+        description: "All sizes up to 1e7 (slow) instead of 1e3 and 1e5"
+        type: boolean
+        default: false
+
+jobs:
+  bench:
+    name: bench ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Tools for the external codes (proxTV needs LAPACK, Condat's files GSL)
+        run: sudo apt-get update && sudo apt-get install -y liblapack-dev libgsl-dev
+      - run: uv sync --python 3.12
+      - name: Machine
+        run: |
+          {
+            lscpu | grep -E 'Model name|^CPU\(s\)|Thread|Core|Socket|MHz|L2|L3' || true
+            cc --version | head -1
+            c++ --version | head -1
+          } | tee machine.txt
+          { echo "### ${{ matrix.os }}"; echo '```'; cat machine.txt; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
+      - name: Overhead, throughput and parallel scaling
+        run: uv run python bench/bench_python.py | tee bench_python.txt
+      - name: Against proxTV and Condat's code
+        run: uv run python bench/compare_external.py ${{ inputs.full && ' ' || '--quick' }} | tee compare_external.txt
+      - name: Summary
+        if: always()
+        run: |
+          for f in bench_python.txt compare_external.txt; do
+            [ -f "$f" ] || continue
+            { echo "#### $f"; echo '```'; cat "$f"; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
+          done
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: bench-${{ matrix.os }}
+          path: "*.txt"

fastprox-0.1.0rc1/.github/workflows/ci.yml

@@ -0,0 +1,138 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:  # also builds the wheels, without a tag
+    inputs:
+      publish:
+        description: Upload the wheels and sdist to TestPyPI
+        type: boolean
+        default: false
+
+jobs:
+  c:
+    name: C/C++ ${{ matrix.os }} ${{ matrix.cc }} openmp=${{ matrix.openmp }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, cc: gcc, cxx: g++, openmp: ON }
+          - { os: ubuntu-latest, cc: clang, cxx: clang++, openmp: ON }
+          - { os: ubuntu-latest, cc: gcc, cxx: g++, openmp: OFF }
+          - { os: macos-latest, cc: clang, cxx: clang++, openmp: ON }
+          - { os: macos-15-intel, cc: clang, cxx: clang++, openmp: ON }
+          - { os: windows-latest, cc: cl, cxx: cl, openmp: ON }
+    steps:
+      - uses: actions/checkout@v4
+      - if: runner.os == 'macOS'
+        run: brew install libomp
+      - name: Configure
+        env: { CC: "${{ matrix.cc }}", CXX: "${{ matrix.cxx }}" }
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DFASTPROX_OPENMP=${{ matrix.openmp }}
+      - run: cmake --build build --config Release
+      - run: ctest --test-dir build -C Release --output-on-failure --timeout 300
+
+  sanitizers:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DFASTPROX_SANITIZE=ON -DFASTPROX_OPENMP=OFF -DFASTPROX_FUZZ=ON
+      - run: cmake --build build
+      - run: ctest --test-dir build --output-on-failure --timeout 300
+
+  valgrind:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: sudo apt-get update && sudo apt-get install -y valgrind
+      - run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DFASTPROX_OPENMP=OFF
+      - run: cmake --build build
+      - name: Memcheck
+        run: |
+          for t in build/tests/c/test_header build/tests/c/test_core; do
+            valgrind --error-exitcode=1 --leak-check=full --errors-for-leak-kinds=definite "$t"
+          done
+
+  python:
+    name: Python ${{ matrix.python }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python: ["3.12"]
+        include:
+          - { os: ubuntu-latest, python: "3.14" }  # the abi3 wheel on a newer CPython
+    steps:
+      - uses: actions/checkout@v4
+      - if: runner.os == 'macOS'
+        run: brew install libomp
+      - uses: astral-sh/setup-uv@v6
+      - run: uv sync --python ${{ matrix.python }}
+      - run: uv run pytest -q
+
+  wheels:
+    name: Wheels ${{ matrix.os }}
+    if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        # macOS runners are pinned: the wheel's minimum macOS is that of the
+        # runner's Homebrew libomp, which must match MACOSX_DEPLOYMENT_TARGET.
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, macos-15-intel, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pypa/cibuildwheel@v3.1
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    name: Source distribution
+    if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build --sdist
+      - name: Tag matches the package version
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          version=$(tar xzf dist/*.tar.gz -O --wildcards '*/PKG-INFO' | sed -n 's/^Version: //p')
+          test "${GITHUB_REF_NAME}" = "v${version}" || {
+            echo "tag ${GITHUB_REF_NAME} does not match version ${version}"; exit 1; }
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  # Trusted publishing (OIDC): no API tokens are stored in the repository.
+  # The publishers are registered on PyPI and TestPyPI for this workflow file
+  # and these environment names.
+  publish-testpypi:
+    name: Publish to TestPyPI
+    if: github.event_name == 'workflow_dispatch' && inputs.publish
+    needs: [c, sanitizers, valgrind, python, wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: { name: testpypi, url: "https://test.pypi.org/p/fastprox" }
+    permissions: { id-token: write }
+    steps:
+      - uses: actions/download-artifact@v4
+        with: { path: dist, merge-multiple: true }
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with: { repository-url: "https://test.pypi.org/legacy/" }
+
+  publish-pypi:
+    name: Publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [c, sanitizers, valgrind, python, wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: { name: pypi, url: "https://pypi.org/p/fastprox" }
+    permissions: { id-token: write }
+    steps:
+      - uses: actions/download-artifact@v4
+        with: { path: dist, merge-multiple: true }
+      - uses: pypa/gh-action-pypi-publish@release/v1

fastprox-0.1.0rc1/.github/workflows/fuzz.yml

@@ -0,0 +1,36 @@
+name: fuzz
+
+on:
+  schedule:
+    - cron: "17 3 * * *"  # nightly
+  workflow_dispatch:
+
+jobs:
+  libfuzzer:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: corpus
+          key: fuzz-corpus-${{ github.run_id }}
+          restore-keys: fuzz-corpus-
+      - name: Build
+        env: { CC: clang, CXX: clang++ }
+        run: |
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo -DFASTPROX_FUZZ=ON \
+                -DFASTPROX_SANITIZE=ON -DFASTPROX_OPENMP=OFF -DBUILD_SHARED_LIBS=OFF
+          cmake --build build --target fuzz_ops
+      - name: Fuzz for 20 minutes
+        run: |
+          mkdir -p corpus
+          ./build/fuzz/fuzz_ops corpus -max_total_time=1200 -timeout=10 -rss_limit_mb=4096 \
+            -max_len=8192 -print_final_stats=1
+      - if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: fuzz-crashes
+          path: |
+            crash-*
+            timeout-*
+            leak-*

fastprox-0.1.0rc1/.gitignore

@@ -0,0 +1,13 @@
+build/
+.venv/
+__pycache__/
+*.egg-info/
+*.so
+*.dylib
+*.pyd
+compile_commands.json
+.pytest_cache/
+.hypothesis/
+dist/
+.cache/
+fuzz-crash.bin

fastprox-0.1.0rc1/.python-version

@@ -0,0 +1 @@
+3.13

fastprox-0.1.0rc1/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to fastprox. Planned work is in [ROADMAP.md](ROADMAP.md).
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased] — 0.1.0rc1
+
+### Added
+
+- Plain-C API (`include/fastprox.h`) over a C++17 core: opaque operator and workspace handles, `fp_prox`, `fp_prox_conj`, `fp_jvp`, `fp_vjp`, error codes with every exception caught at the boundary.
+- Operators: soft thresholding (weighted), elastic net, Huber, group ℓ2 and ℓ2 norm, box, nonnegative orthant, ℓ2 ball, simplex, weighted ℓ1 ball, ℓ∞ norm, isotonic regression, and 1D TV (Condat's direct algorithm and taut string, edge weights).
+- JVP and VJP in the input, the step and the operator parameters for every operator.
+- Batching over any axis of strided n-d arrays, OpenMP parallelism with bit-identical results for any thread count, and allocation-free calls with a workspace.
+- Python package built with nanobind (abi3, CPython ≥ 3.12): one-shot functions and operator classes with `prox`, `prox_conj`, `jvp` and `vjp`.
+- C/C++ and Python test suites, a benchmark script, and a CI workflow.
+- Release pipeline: sdist job, trusted publishing to TestPyPI (manual dispatch with `publish`) and to PyPI (tags `v*`, checked against the package version); PyPI metadata and a README for the project page; pre-release tags through `FASTPROX_VERSION_SUFFIX` in `CMakeLists.txt`; Python tests also run on CPython 3.14.
+- Fuzz harness for the whole API (libFuzzer target and standalone driver) with a nightly workflow; CVXPY + Clarabel reference fixtures; benchmarks against proxTV and Condat's code (`bench/compare_external.py`, `docs/benchmarks.md`); API reference (`docs/api.md`); Valgrind CI job.
+
+### Changed
+
+- 1D TV: the Condat path falls back to the taut string after 3n + 1024 rescanned steps (was 16n + 1024 steps in total), which makes adversarial inputs such as ramps about 3.5× cheaper without affecting typical signals.
+- 1D TV: the bound updates of Condat's algorithm are branch-free selects with a table of reciprocals, 25–35% faster on noisy signals (same arithmetic, so the same results).
+- 1D TV: weighted problems now use Condat's direct algorithm, generalised to per-edge weights (radii precomputed per piece), with the same budgeted fallback to the taut string; `FP_TV1D_CONDAT` accepts weights. Weighted rows went from 1.4–2.8× slower than proxTV's weighted taut string to faster in most settings.
+- 1D TV: radii that can never be active (above the dual bound j · (max x − min x)) are clamped, and when no edge can be active the result is the constant mean. Extreme weights or steps no longer cost accuracy: the residual stays within 10 n ε ‖x‖∞.
+- 1D TV: the taut string stores its two chains as segments (length, rise, cached slope) in coordinates local to the current knot, an idea taken from proxTV's classic taut string. It is 17–26% faster and needs no compensated sums: the cumulative sum of the signal is never formed.
+- Unweighted simplex and ℓ1-ball projections keep candidate values instead of indices (about 30% faster). The simplex also tests finiteness inside its pivot pass instead of a separate pass (a further 19%), and the ℓ1 ball and ℓ∞ prox reuse their ℓ1 norm as the test.
+- 1D TV: bound updates are branch-free only in the first 8 samples of a segment; weighted rows read their radii directly when none can need clamping; operator construction makes one pass over the weights.
+- Workspace scratch is no longer zero-filled, and the finiteness check is a branch-free pass: one-shot calls on large rows are noticeably faster.
+- The version is defined once, in `CMakeLists.txt`; the Python package reads it from there.
+
+### Fixed
+
+- Weighted ℓ1-ball projection returned infinities for tiny weights (around 1e-279) because sums of squared weights underflowed (found by fuzzing). Weights are now normalised by their maximum, and ratios below 1e-100 are rejected.
+- `fp_prox_conj` with σ = 0 on arrays with negative strides computed byte offsets in unsigned arithmetic (undefined behaviour, found by fuzzing).
+- Static Windows builds marked API symbols `dllexport`.
+- The taut string kept cumulative sums in plain doubles and missed the 10 n ε ‖x‖∞ accuracy bound on long rows; its chains now use local coordinates.
+- A test assumed weighted isotonic regression is firmly nonexpansive in the Euclidean norm; it is so in the weighted norm, which the test now uses.

fastprox-0.1.0rc1/CLAUDE.md

@@ -0,0 +1,34 @@
+# fastprox
+
+Exact proximal operators with JVP/VJP. C++17 core behind the plain-C header
+`include/fastprox.h`; Python bindings via nanobind. The design spec is
+`docs/spec.md` — read it before changing the API or adding operators.
+
+## Commands
+
+- C library and tests: `cmake -S . -B build/c -G Ninja && cmake --build build/c && ./build/c/tests/c/test_core && ./build/c/tests/c/test_header`
+- Sanitizers: configure a second tree with `-DFASTPROX_SANITIZE=ON -DFASTPROX_OPENMP=OFF -DCMAKE_BUILD_TYPE=Debug`
+- Python (always through uv): `uv sync`, `uv run pytest -q`. uv rebuilds the extension when C++ sources change (`tool.uv.cache-keys`).
+- Benchmarks: `uv run python bench/bench_python.py`
+- Releasing: set the version in `project()` and `FASTPROX_VERSION_SUFFIX` (`CMakeLists.txt`) and the macros in `fastprox.h`; dry run with `gh workflow run ci.yml -f publish=true` (TestPyPI); then push the tag `v<version>`, which publishes to PyPI.
+
+## Layout
+
+- `src/core/op.hpp` — `fp_op` base class; `ElemOp<D>` (elementwise, needs `prox1`/`deriv1`) and `RowOp<D>` (row kernels `prox`/`jvp`/`vjp`) CRTP helpers.
+- `src/core/driver.hpp` — batching over strided n-d arrays, OpenMP, saved structure; `src/core/layout.hpp` — row and elementwise iteration plans.
+- `src/ops/*.cpp` — one file per operator family, each with a `make_*` factory declared in `src/ops/ops.hpp`.
+- `src/api/api.cpp` — the only `extern "C"` code: validation, dtype dispatch, try/catch.
+- `bindings/python/src/module.cpp` calls only the C API; `bindings/python/fastprox/__init__.py` is the user-facing package.
+
+## Tracking
+
+- `ROADMAP.md` lists planned work per release with status boxes; tick items as they land and add new ones as they come up.
+- `CHANGELOG.md` records finished changes under `[Unreleased]`, in the same change that makes them.
+- Any decision that departs from `docs/spec.md` goes in the decisions table at the end of `ROADMAP.md`, with its date.
+
+## Rules
+
+- Clean room: never read GPL, CeCILL or unlicensed code (Condat's C files, Kolmogorov's maxflow/TVTree, Chambolle's graphTV, PyMaxflow, gco). Implement from papers and cite them in the kernel's header comment. proxTV (BSD) may be consulted with attribution.
+- No `-ffast-math`. Results must be bit-identical for any thread count: rows are independent, and cross-row sums (vjp parameter gradients) use fixed blocks from `reduction_blocks`, never thread-dependent partitions.
+- No allocation inside `fp_prox`/`fp_jvp`/`fp_vjp` when a workspace is given; size everything in `build_workspace` (tested by an allocation counter in `tests/c/test_core.cpp`).
+- Adding an operator: kernel + derivatives in `src/ops/`, factory in `ops.hpp`, constructor in `fastprox.h` and `api.cpp`, nanobind wrapper, Python class with `_layout`, and an entry in `CASES` in `tests/python/test_operators.py` (which runs reference, finite-difference, adjointness, nonexpansiveness, threading and stride tests on it) plus `derivative_cases` in `tests/c/test_core.cpp`.

fastprox-0.1.0rc1/CMakeLists.txt

@@ -0,0 +1,161 @@
+cmake_minimum_required(VERSION 3.20)
+project(fastprox VERSION 0.1.0 LANGUAGES C CXX)
+# PEP 440 pre-release tag (a1, rc1, ...) appended to the version; empty for a
+# final release. pyproject.toml reads both lines.
+set(FASTPROX_VERSION_SUFFIX "rc1")
+set(FASTPROX_VERSION_FULL "${PROJECT_VERSION}${FASTPROX_VERSION_SUFFIX}")
+
+option(FASTPROX_OPENMP "Parallelise over rows with OpenMP" ON)
+option(FASTPROX_BUILD_TESTS "Build the C and C++ tests" ${PROJECT_IS_TOP_LEVEL})
+option(FASTPROX_PYTHON "Build the nanobind Python extension" OFF)
+option(FASTPROX_SANITIZE "Build with AddressSanitizer and UBSan" OFF)
+option(FASTPROX_FUZZ "Build the fuzzing harnesses" OFF)
+option(BUILD_SHARED_LIBS "Build libfastprox as a shared library" ON)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+include(GNUInstallDirs)
+
+# Windows finds DLLs next to the executable: keep the library, tests and fuzz
+# drivers in one directory, or every test hangs on a "DLL not found" dialog.
+if(WIN32 AND NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+endif()
+
+# project() above is the single source of the version (pyproject.toml reads it
+# too); the public header's macros must agree with it.
+file(STRINGS include/fastprox.h _fp_version_lines REGEX "#define FP_VERSION_(MAJOR|MINOR|PATCH) ")
+string(REGEX REPLACE ".*MAJOR ([0-9]+).*MINOR ([0-9]+).*PATCH ([0-9]+).*" "\\1.\\2.\\3"
+  _fp_header_version "${_fp_version_lines}")
+if(NOT _fp_header_version STREQUAL PROJECT_VERSION)
+  message(FATAL_ERROR "fastprox.h declares version ${_fp_header_version}, "
+                      "CMakeLists.txt ${PROJECT_VERSION}")
+endif()
+
+# The Python extension links the core statically.
+if(FASTPROX_PYTHON)
+  set(BUILD_SHARED_LIBS OFF)
+endif()
+
+add_library(fastprox
+  src/api/api.cpp
+  src/ops/pointwise.cpp
+  src/ops/group.cpp
+  src/ops/projections.cpp
+  src/ops/isotonic.cpp
+  src/ops/tv1d.cpp
+)
+add_library(fastprox::fastprox ALIAS fastprox)
+
+target_include_directories(fastprox
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+target_compile_definitions(fastprox
+  PRIVATE FASTPROX_BUILDING FASTPROX_VERSION_STRING="${FASTPROX_VERSION_FULL}")
+if(NOT BUILD_SHARED_LIBS)
+  target_compile_definitions(fastprox PUBLIC FASTPROX_STATIC)
+endif()
+set_target_properties(fastprox PROPERTIES
+  CXX_VISIBILITY_PRESET hidden
+  VISIBILITY_INLINES_HIDDEN ON
+  POSITION_INDEPENDENT_CODE ON
+  VERSION ${PROJECT_VERSION}
+  SOVERSION ${PROJECT_VERSION_MAJOR}
+)
+
+# No -ffast-math anywhere: the direct algorithms compare running bounds and
+# determinism depends on the order of floating-point operations.
+if(MSVC)
+  target_compile_options(fastprox PRIVATE /W4 /fp:precise)
+else()
+  target_compile_options(fastprox PRIVATE -Wall -Wextra -Wno-unknown-pragmas -fno-fast-math)
+endif()
+
+if(FASTPROX_OPENMP)
+  if(APPLE AND NOT OpenMP_ROOT)
+    # Apple Clang ships without libomp; use Homebrew's when present.
+    foreach(_prefix /opt/homebrew/opt/libomp /usr/local/opt/libomp)
+      if(EXISTS "${_prefix}/include/omp.h")
+        set(OpenMP_ROOT "${_prefix}")
+        break()
+      endif()
+    endforeach()
+  endif()
+  find_package(OpenMP COMPONENTS CXX)
+  if(OpenMP_CXX_FOUND)
+    target_link_libraries(fastprox PRIVATE OpenMP::OpenMP_CXX)
+  else()
+    message(WARNING "OpenMP not found: fastprox will run serially")
+  endif()
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  # Keep the host libstdc++ out of the picture (MATLAB, old distributions).
+  target_link_options(fastprox PRIVATE -static-libstdc++ -static-libgcc)
+endif()
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND BUILD_SHARED_LIBS)
+  target_link_options(fastprox PRIVATE
+    "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/cmake/fastprox.map")
+endif()
+
+if(FASTPROX_SANITIZE AND NOT MSVC)
+  add_compile_options(-fsanitize=address,undefined -fno-omit-frame-pointer)
+  add_link_options(-fsanitize=address,undefined)
+  target_compile_options(fastprox PRIVATE -fsanitize=address,undefined -fno-omit-frame-pointer)
+  target_link_options(fastprox PUBLIC -fsanitize=address,undefined)
+endif()
+
+# ---------------------------------------------------------------- install
+if(NOT FASTPROX_PYTHON)
+  include(CMakePackageConfigHelpers)
+  install(TARGETS fastprox EXPORT fastproxTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  install(FILES include/fastprox.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  install(EXPORT fastproxTargets NAMESPACE fastprox::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fastprox)
+  configure_package_config_file(cmake/fastproxConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/fastproxConfig.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fastprox)
+  write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/fastproxConfigVersion.cmake
+    COMPATIBILITY SameMajorVersion)
+  install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/fastproxConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/fastproxConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fastprox)
+  configure_file(cmake/fastprox.pc.in ${CMAKE_CURRENT_BINARY_DIR}/fastprox.pc @ONLY)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/fastprox.pc
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+endif()
+
+# ---------------------------------------------------------------- tests
+if(FASTPROX_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(tests/c)
+endif()
+
+if(FASTPROX_FUZZ)
+  if(NOT FASTPROX_BUILD_TESTS)
+    enable_testing()
+  endif()
+  add_subdirectory(fuzz)
+endif()
+
+# ---------------------------------------------------------------- python
+if(FASTPROX_PYTHON)
+  add_subdirectory(bindings/python)
+endif()

fastprox-0.1.0rc1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Villacís
+
+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.

fastprox-0.1.0rc1/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: fastprox
+Version: 0.1.0rc1
+Summary: Exact proximal operators and projections with derivatives
+Keywords: proximal operator,projection,total variation,optimization,bilevel,autodiff
+Author-Email: David Villacís <david@villacis.net>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Project-URL: Homepage, https://github.com/dvillacis/fastprox
+Project-URL: Documentation, https://github.com/dvillacis/fastprox/blob/master/docs/api.md
+Project-URL: Changelog, https://github.com/dvillacis/fastprox/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/dvillacis/fastprox/issues
+Requires-Python: >=3.12
+Requires-Dist: numpy>=1.26
+Description-Content-Type: text/markdown
+
+# fastprox
+
+Exact proximal operators and projections with derivatives. A C++17 core
+behind a plain-C API, with Python bindings.
+
+- **Exact.** Direct algorithms (Condat's 1D TV and simplex projection, the
+  taut string, pool-adjacent-violators) instead of iterative solvers.
+- **Differentiable.** Jacobian-vector and vector-Jacobian products in the
+  input, the step and the operator's parameters, for bilevel learning and
+  implicit differentiation.
+- **Batched.** Applied along any axis of a float32 or float64 array, with rows
+  processed in parallel by OpenMP and results bit-identical for any number of
+  threads.
+- **Permissive.** MIT licensed; every kernel is written from the papers.
+
+## Install
+
+```sh
+pip install --pre fastprox     # 0.1.0rc1, a release candidate
+```
+
+Wheels are abi3 for CPython 3.12 and later on Linux (x86_64, aarch64), macOS
+(arm64 from 14.0, x86_64 from 15.0) and Windows (amd64), with the OpenMP
+runtime bundled.
+
+## Use
+
+```python
+import numpy as np
+import fastprox as fp
+
+x = np.random.default_rng(0).normal(size=(64, 1000))
+
+z = fp.tv1d(x, gamma=0.5)                 # 1D total variation along the last axis
+p = fp.project_simplex(x, radius=1.0)     # each row onto the simplex
+s = fp.soft_threshold(x, lam=0.1)
+
+# Operators with derivatives
+op = fp.TV1D(weights=0.8)
+z, ctx = op.prox(x, 0.5, keep=True)
+dz = op.jvp(ctx, dx=np.ones_like(x))      # Jacobian-vector product
+gx, grads = op.vjp(ctx, g=x)              # vector-Jacobian product
+print(grads.gamma, grads.weights)         # gradients in the step and the weights
+```
+
+## Operators (0.1)
+
+Soft thresholding (weighted), elastic net, Huber, group ℓ2, box,
+nonnegative orthant, ℓ2 ball, simplex, weighted ℓ1 ball, ℓ∞ norm, isotonic
+regression, and 1D total variation with per-edge weights. Each one has a
+conjugate prox through the Moreau identity.
+
+## Documentation
+
+- [API reference](https://github.com/dvillacis/fastprox/blob/master/docs/api.md) (C and Python)
+- [Benchmarks](https://github.com/dvillacis/fastprox/blob/master/docs/benchmarks.md) against proxTV and Condat's C code
+- [Design specification](https://github.com/dvillacis/fastprox/blob/master/docs/spec.md)
+- [Roadmap](https://github.com/dvillacis/fastprox/blob/master/ROADMAP.md) and [changelog](https://github.com/dvillacis/fastprox/blob/master/CHANGELOG.md)
+
+## C library
+
+```sh
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build && cmake --install build --prefix /usr/local
+```
+
+Then `find_package(fastprox)` and link `fastprox::fastprox`, or use
+`pkg-config --cflags --libs fastprox`. The header is
+[`include/fastprox.h`](https://github.com/dvillacis/fastprox/blob/master/include/fastprox.h).
+
+## License
+
+MIT