fastprox 0.1.0__tar.gz

fastprox-0.1.0/.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.0/.github/workflows/ci.yml

@@ -0,0 +1,151 @@
+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 }} threads=${{ matrix.threads }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, cc: gcc, cxx: g++, threads: ON }
+          - { os: ubuntu-latest, cc: clang, cxx: clang++, threads: ON }
+          - { os: ubuntu-latest, cc: gcc, cxx: g++, threads: OFF }
+          - { os: macos-latest, cc: clang, cxx: clang++, threads: ON }
+          - { os: macos-15-intel, cc: clang, cxx: clang++, threads: ON }
+          - { os: windows-latest, cc: cl, cxx: cl, threads: ON }
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure
+        env: { CC: "${{ matrix.cc }}", CXX: "${{ matrix.cxx }}" }
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DFASTPROX_THREADS=${{ matrix.threads }}
+      - 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_FUZZ=ON
+      - run: cmake --build build
+      - run: ctest --test-dir build --output-on-failure --timeout 300
+
+  tsan:
+    name: ThreadSanitizer
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # TSan in clang 18 rejects the runner kernel's high ASLR entropy.
+      - run: sudo sysctl vm.mmap_rnd_bits=28
+      - name: Configure
+        env: { CC: clang, CXX: clang++ }
+        run: >
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+          -DCMAKE_C_FLAGS=-fsanitize=thread -DCMAKE_CXX_FLAGS=-fsanitize=thread
+          -DCMAKE_EXE_LINKER_FLAGS=-fsanitize=thread -DCMAKE_SHARED_LINKER_FLAGS=-fsanitize=thread
+      - run: cmake --build build
+      - run: ctest --test-dir build --output-on-failure --timeout 300
+        env: { TSAN_OPTIONS: "halt_on_error=1" }
+
+  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
+      - 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 \
+              --suppressions=tests/valgrind/fork.supp "$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
+      - 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-15-intel builds the x86_64 wheel natively, so its tests run.
+        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, tsan, 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, tsan, 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.0/.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_THREADS=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.0/.github/workflows/profile.yml

@@ -0,0 +1,99 @@
+name: profile
+
+# Single-thread profile of 1D TV on GitHub's x86_64 runner, fastprox against
+# proxTV, with hardware counters where the VM exposes them and GCC's assembly
+# of the kernels. `ubuntu-latest` lands on an Intel or an AMD CPU at random,
+# so this starts several identical jobs and labels each artifact with the CPU
+# it got. Started by hand from the Actions tab.
+on:
+  workflow_dispatch:
+    inputs:
+      jobs:
+        description: "Identical jobs to start (each lands on a random CPU), 1 to 12"
+        type: string
+        default: "6"
+      n:
+        description: "Samples per row"
+        type: string
+        default: "100000"
+      reps:
+        description: "Repetitions per setting (fresh input each)"
+        type: string
+        default: "31"
+
+jobs:
+  slots:
+    runs-on: ubuntu-latest
+    outputs:
+      list: ${{ steps.s.outputs.list }}
+    steps:
+      - id: s
+        env: { JOBS: "${{ inputs.jobs }}" }
+        run: |
+          python3 - <<'EOF' >> "$GITHUB_OUTPUT"
+          import json, os
+          k = max(1, min(12, int(os.environ["JOBS"])))
+          print("list=" + json.dumps(list(range(1, k + 1))))
+          EOF
+
+  profile:
+    name: profile ${{ matrix.slot }}
+    needs: slots
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        slot: ${{ fromJSON(needs.slots.outputs.list) }}
+    env: { N: "${{ inputs.n }}", REPS: "${{ inputs.reps }}" }
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Machine
+        id: machine
+        run: |
+          {
+            lscpu | grep -E 'Model name|^CPU\(s\)|Thread|Core|Socket|MHz|L2|L3' || true
+            c++ --version | head -1
+          } | tee machine.txt
+          model=$(lscpu | sed -n 's/^Model name: *//p' | head -1)
+          case "$model" in
+            *Intel*|*INTEL*) vendor=intel ;;
+            *AMD*) vendor=amd ;;
+            *) vendor=other ;;
+          esac
+          echo "vendor=$vendor" >> "$GITHUB_OUTPUT"
+          echo "### profile ${{ matrix.slot }}: $model" >> "$GITHUB_STEP_SUMMARY"
+      - name: Allow hardware counters for this user
+        run: sudo sysctl -w kernel.perf_event_paranoid=1 || true
+      - name: Build fastprox
+        run: |
+          cmake -S . -B build/c -DCMAKE_BUILD_TYPE=Release
+          cmake --build build/c --target fastprox -j 4
+      - name: Build proxTV (fetched at run time, never vendored)
+        run: |
+          sudo apt-get update && sudo apt-get install -y liblapack-dev
+          uv sync --python 3.12
+          uv run python -c "import sys; sys.path.insert(0, 'bench'); import compare_external as c; print(c.build_proxtv())"
+      - name: Profile
+        run: |
+          c++ -O2 -std=c++17 bench/profile_kernels.cpp -Iinclude -Lbuild/c -lfastprox -ldl \
+              -Wl,-rpath,"$PWD/build/c" -o profile_kernels
+          ./profile_kernels build/external/libproxtv_tv1.so "$N" "$REPS" | tee profile.txt
+          { echo '```'; cat profile.txt; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
+      - name: Assembly of the kernels (same flags as the library)
+        run: |
+          for f in tv1d projections; do
+            c++ -std=c++17 -O3 -DNDEBUG -fno-fast-math -Iinclude -Isrc -S "src/ops/$f.cpp" -o "$f.s"
+          done
+          python3 bench/asm_summary.py tv1d.s projections.s | tee asm_summary.txt
+          { echo '```'; cat asm_summary.txt; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: profile-${{ matrix.slot }}-${{ steps.machine.outputs.vendor }}
+          path: |
+            machine.txt
+            profile.txt
+            asm_summary.txt
+            tv1d.s
+            projections.s

fastprox-0.1.0/.github/workflows/variants.yml

@@ -0,0 +1,89 @@
+name: variants
+
+# Variants of the 1D TV kernel side by side against proxTV, in one binary per
+# job (bench/tv_variants.cpp), on GitHub's arm64 runner (Neoverse-N2) and on
+# x86_64 jobs that land on random Intel or AMD CPUs. Comparing within a job
+# keeps the CPU out of the comparison. Runs on every push to a branch named
+# variants/<topic>, or by hand from the Actions tab.
+on:
+  push:
+    branches: ["variants/**"]
+  workflow_dispatch:
+    inputs:
+      x86_jobs:
+        description: "x86_64 jobs (each lands on a random CPU), 0 to 8"
+        type: string
+        default: "3"
+      n:
+        description: "Samples per row"
+        type: string
+        default: "100000"
+      reps:
+        description: "Repetitions per setting (fresh input each)"
+        type: string
+        default: "31"
+
+jobs:
+  matrix:
+    runs-on: ubuntu-latest
+    outputs:
+      include: ${{ steps.m.outputs.include }}
+    steps:
+      - id: m
+        env: { X86: "${{ inputs.x86_jobs || '3' }}" }
+        run: |
+          python3 - <<'EOF' >> "$GITHUB_OUTPUT"
+          import json, os
+          k = max(0, min(8, int(os.environ["X86"])))
+          jobs = [{"os": "ubuntu-24.04-arm", "slot": 0}] + [{"os": "ubuntu-latest", "slot": i} for i in range(1, k + 1)]
+          print("include=" + json.dumps(jobs))
+          EOF
+
+  variants:
+    name: variants ${{ matrix.os }} ${{ matrix.slot }}
+    needs: matrix
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(needs.matrix.outputs.include) }}
+    env: { N: "${{ inputs.n || '100000' }}", REPS: "${{ inputs.reps || '31' }}" }
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Machine
+        id: machine
+        run: |
+          {
+            lscpu | grep -E 'Model name|^CPU\(s\)|Thread|Core|Socket|MHz|L2|L3' || true
+            c++ --version | head -1
+          } | tee machine.txt
+          model=$(lscpu | sed -n 's/^Model name: *//p' | head -1)
+          case "$model" in
+            *Intel*|*INTEL*) cpu=intel ;;
+            *AMD*) cpu=amd ;;
+            *Neoverse*) cpu=neoverse ;;
+            *) cpu=other ;;
+          esac
+          echo "cpu=$cpu" >> "$GITHUB_OUTPUT"
+          echo "### variants ${{ matrix.slot }}: $model" >> "$GITHUB_STEP_SUMMARY"
+      - name: Build proxTV (fetched at run time, never vendored)
+        run: |
+          sudo apt-get update && sudo apt-get install -y liblapack-dev
+          uv sync --python 3.12
+          uv run python -c "import sys; sys.path.insert(0, 'bench'); import compare_external as c; print(c.build_proxtv())"
+      - name: Variants
+        run: |
+          c++ -std=c++17 -O3 -DNDEBUG -fno-fast-math -Iinclude -Isrc bench/tv_variants.cpp \
+              src/api/api.cpp src/core/parallel.cpp src/ops/pointwise.cpp src/ops/group.cpp \
+              src/ops/projections.cpp src/ops/isotonic.cpp -DFASTPROX_BUILDING \
+              -DFASTPROX_VERSION_STRING='"variants"' -ldl -lpthread -o tv_variants
+          ./tv_variants build/external/libproxtv_tv1.so "$N" "$REPS" | tee variants.txt
+          { echo '```'; cat variants.txt; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: variants-${{ matrix.slot }}-${{ steps.machine.outputs.cpu }}
+          path: |
+            machine.txt
+            variants.txt

fastprox-0.1.0/.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.0/.python-version

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

fastprox-0.1.0/CHANGELOG.md

@@ -0,0 +1,84 @@
+# 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.0] — 2026-10-16
+
+First release. Changes since 0.1.0rc2:
+
+### Added
+
+- `variants` workflow and `bench/tv_variants.cpp`: variants of the 1D TV kernel side by side against proxTV (classic, linearized, hybrid and weighted taut string), compiled into one binary and timed on the same inputs with the order rotated, on the arm64 runner and on x86_64 jobs. It runs on pushes to `variants/*` branches or by hand. `condat` takes the length of its first, paper-form phase as a template parameter (`kShort` by default) so variants need no copy of the kernel.
+
+- `profile` workflow (manual dispatch): several identical jobs on GitHub's x86_64 runner, each labelled with the CPU it landed on. Each job profiles single-thread 1D TV against proxTV with `bench/profile_kernels.cpp`, which records hardware counters where the VM exposes them and rotates the solver order so that none benefits from branch history. It also summarises GCC's assembly of the kernels (conditional jumps against selects) with `bench/asm_summary.py`.
+
+### Documentation
+
+- `examples/`: basic usage, 1D TV denoising, proximal gradient (lasso and batched simplex least squares), derivatives checked against finite differences, and bilevel learning of TV weights through the VJP. `tests/python/test_examples.py` runs them all; matplotlib for the plot is in the `examples` dependency group.
+- `docs/api.md` lists, for every operator, which Jacobian the derivatives use at kinks and ties. It explains why each choice is an element of the B-subdifferential, and that the x, γ and parameter derivatives together form one. The ℓ∞ prox and conjugate proxes reverse the thresholding rule through the Moreau identity.
+
+### Changed
+
+- `bench/compare_external.py` rotates the order of the solvers with every repetition (fastprox's default solver always ran first, on an input just written, and its Condat path right after it), and quick mode takes the median of 7 repetitions instead of 3.
+- 1D TV: the per-call finiteness and range pass runs in 8 independent lanes with `fminnm`/`fmaxnm` on arm64 (compare-selects elsewhere) instead of one dependent chain: 0.25 instead of 0.48 ns per sample with Clang and 0.89 with GCC on Apple M5 (float64, n = 10⁶). Weighted rows on white noise at λ = 10 went from 5.52 to 5.29 ns per sample, and float32 rows at λ = 0.1 are now 1–5% behind Condat's single-precision code (were 6–12%).
+- 1D TV: the branch-free bound updates in short segments of Condat's algorithm are written as min/max of the excess instead of selects on a comparison, which GCC compiled back into branches. Same arithmetic up to the sign of zero. With GCC 16 on Apple M5, 4–12% faster at λ = 0.1 and 5–27% faster at λ = 1 (uniform and weighted), within 3% of the Clang build at λ ≤ 1; at λ = 10, uniform rows lose 1–19% under GCC (random walk most), where the branches it emitted happened to predict well, and weighted rows gain up to 10%. Clang's code is unchanged.
+- Simplex and ℓ1 ball: the first pass of Condat's method skips blocks of 8 entries whose maximum is at or below the running pivot (the pivot can only change on an entry above it, so results are bit-identical). The ℓ1 norm that decides whether x is inside the ball is summed in 8 lanes instead of one dependent chain. On Apple M5 at n = 10⁶: simplex projection 0.50 instead of 0.60 ns per sample on Gaussian input, now faster than Condat's code (0.56); unweighted ℓ1 ball 0.64 instead of 1.08, weighted 1.08 instead of 1.37 (Clang) and 1.05 instead of 1.68 (GCC). The ℓ∞ prox shares the ℓ1-ball kernel.
+
+- x86-64: the min/max helpers behind 1D TV's bound updates and range pass and the simplex block maximum use SSE2 `minsd`/`maxsd` instead of a compare-select, which GCC compiled into compare-and-branch. Same values. On GitHub's x86_64 runners (GCC 13.3, n = 10⁵), 1D TV went from fastest or within 2% of proxTV in 3–6 of 18 settings to 12–13 on Intel Xeons (8573C, 6973P-C) and from 14–17 to 17–18 on AMD EPYC; at λ = 1 fastprox now takes 0.82–1.03 of proxTV's time on Intel (was 1.01–1.16). Uniform random walk at λ = 10 lost 5–11% relative to proxTV, where the branches predicted well.
+
+- 1D TV: after the first 3 samples of a segment, Condat's algorithm now tracks the segment by its running sum. The lower bound is the running maximum of the candidates (s − λₖ)/m and the upper bound the running minimum of (s + λₖ)/m, so the clamps are min/max and the only value carried between steps is the sum, instead of a dependency chain through every clamp (same algorithm and structure; values differ at rounding level). On Apple M5 (n = 10⁵, single thread) the kernel is 1.3–2.9× faster at λ ≥ 1 and unchanged at λ = 0.1. Weighted white noise at λ = 10, the one setting where fastprox trailed proxTV on every machine, went from 1.03–1.09 of proxTV's time to 0.43–0.45 (Clang) and from 1.14 to 0.60 (GCC 16), and uniform random walk at λ = 10 from 0.99 to 0.64. On GitHub's runners (GCC 13.3): weighted white noise at λ = 10 from 1.12–1.14 to 0.73–0.78 on Intel Xeons, from 1.00–1.08 to 0.55–0.62 on AMD EPYC and from 1.22 to 0.92 on Neoverse-N2; uniform random walk at λ = 10 from 1.05–1.09 to 0.83–0.84 on Intel and from 1.19 to 1.06 on Neoverse-N2. At λ = 0.1 weighted rows lost about 3% on Intel. Long segments no longer use branches for the clamps, so `kBranchFree` (8) is replaced by `kShort` (3).
+
+### Fixed
+
+- Weighted ℓ1-ball projection with weights spanning many orders of magnitude could return outputs far larger than the input (z = [5.5e7, 2.4e70] for x = [11.0, 2.0], weights [1.8e-308, 7.7e-246] and radius 1e-300; found by fuzzing). Removing an entry within rounding of the pivot that dominated the running sums cancelled them. The threshold is now kept at least at the largest breakpoint left out of the support, as it is in exact arithmetic. The same guard is in the unweighted kernel.
+
+## [0.1.0rc2] — 2026-10-15
+
+### Fixed
+
+- The macOS wheel of 0.1.0rc1 aborted the process (`OMP: Error #15`) when PyTorch, or any package bundling a recent LLVM OpenMP runtime, was used in the same process: each wheel carried its own libomp, and the copies refuse to coexist.
+
+### Changed
+
+- Rows run on fastprox's own thread pool (`src/core/parallel.cpp`) instead of OpenMP. No OpenMP runtime is linked or bundled on any platform; the wheels depend only on the system and NumPy, and macOS wheels now support macOS 11.0 (arm64) and 10.15 (x86_64). Same results bit for bit; dynamic scheduling as before. Measured against the OpenMP build on Apple M5 in one process: equal on one thread, 1–8% slower at 2–4 threads on small batches, 8–31% faster at 8–15 threads.
+- `threads = 0` means `fp_default_threads()`: `FASTPROX_NUM_THREADS`, else the first number in `OMP_NUM_THREADS`, else the CPUs the process may use (CPU affinity on Linux). Concurrent callers do not oversubscribe: one uses the pool, the others run serially. A child after `fork()` builds its own pool.
+- `fp_has_openmp()` and `fastprox.has_openmp()` are replaced by `fp_default_threads()` and `fastprox.default_threads()`; the CMake option `FASTPROX_OPENMP` is now `FASTPROX_THREADS`.
+- CI: a ThreadSanitizer job; AddressSanitizer and Valgrind now run with threads.
+
+## [0.1.0rc1] — 2026-10-15
+
+First release candidate, on PyPI (`pip install --pre fastprox`).
+
+### 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.0/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 -DCMAKE_BUILD_TYPE=Debug` (ThreadSanitizer: `-fsanitize=thread` in the C/C++ and linker flags, as in the `tsan` CI job)
+- 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, saved structure; `src/core/parallel.cpp` — the thread pool (no OpenMP: bundled libomp copies abort each other, e.g. next to PyTorch); `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`.