Dev

.github/workflows/ci.yml

@@ -17,11 +17,22 @@ jobs:
         run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DNP_WERROR=ON
       - name: Build
         run: cmake --build build -j8
-      - name: Test 49/49
+      - name: Test 52/52
         run: ctest --test-dir build --output-on-failure
       - name: Bench hardware (smoke)
         run: ./build/tests/bench_hardware || true
 
+  windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure (MSVC, Release)
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DNP_WERROR=ON
+      - name: Build
+        run: cmake --build build --config Release --parallel 8
+      - name: Test
+        run: ctest --test-dir build -C Release --output-on-failure
+
   sanitize:
     runs-on: ubuntu-latest
     strategy:

CHANGELOG.md

@@ -2,10 +2,25 @@
 
 All notable changes to `numpy-cpp` will be documented here. Format based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), versioning follows [SemVer](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased] — honesty pass + 49/49 suites
+## [Unreleased] — honesty pass + 52/52 suites
+
+### Added
+- **ABI versioning** — new `abi.hpp`: `NP_VERSION_MAJOR/MINOR/PATCH`, `NP_ABI_VERSION` (CMake cache option, `INTERFACE` compile definition, header `#error` guard on mismatch), inline namespace `np::v1` with `np::abi::version()/version_string()/abi_tag()` helpers. All subsystems migrated to `namespace np::v1::<sub>` (69 files; `np::X` still resolves via inline). New `tests/test_abi` (macro checks, 7 compile-time type identities, `fft` function identity, versioned-spelling calls).
+- **Bundle hardening** — `bundle.hpp`: exact `bigint` binomial (fixes overflow for `CP^n`, `n ≥ 67`), strict `P^` parsing with `inconclusive` fallback (no `stoi` throw), corrected `T S^n` Stiefel–Whitney to trivial `w = 1`, corrected `T CP^n` Pontryagin to `p_k = C(n+1,k)`, fixed Hodge star to single-application `sign(I,J)` (`** = (−1)^{k(n−k)}` preserved), real `δ = ±⋆d⋆` / `Δ = dδ + δd` instead of zero stubs. New `tests/test_bundle` (binom, `CP^70`, malformed/negative-dim, Whitney convolution, Klein, Hodge signs/involution, `CP^3 p1 = 4`).
+- **Leech lattice** — `LatticeFactory::leech()` (was a documented stub): Λ24 via extended binary Golay-code lifting (12 cyclic-shift code lifts + 11 pair vectors + verified odd row, scaled by 1/√8), with `detail::golay24_*` helpers. Provenance verified in `test_lattice.cpp`: Golay weight enumerator {0:1, 8:759, 12:2576, 16:759, 24:1}, exact integer-preimage determinant 2^36 (⇒ unimodular), even Gram matrix, GF(2) row space {0, all-ones}, exhaustive no-roots search (170016 candidates), all 1104 type-(±4,±4) and sampled octad type-(±2⁸) minimal vectors in span — hence Λ24 by Niemeier uniqueness.
+- **Vector math library** — new `vecmath.hpp`: dependency-free SLEEF/SVML-class SIMD kernels (`exp`, `expm1`, `exp2`, `log`, `log10`, `log2`, `log1p`, `sin`, `cos`, `sincos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `sqrt`, `cbrt`, `pow`, `hypot`, `floor`, `ceil`, `trunc`, `rint`, `fabs` for `float`/`double`). Single-source portable abstraction over AVX-512/AVX2/SSE2/NEON/scalar tiers, Cody-Waite range reduction, ≤2 ULP exp/log, ≤4 ULP trig/hyperbolic, exact small-`pow` exponents, IEEE edge cases bit-compatible with libm. `simd.hpp` dispatches to it (SLEEF still preferred for `sin/cos/exp/log` when `NP_ENABLE_SLEEF`), `math.hpp` gained contiguous fast paths for every transcendental ufunc (`tan`, `arcsin`/`arccos`/`arctan`/`arctan2`, `sinh`/`cosh`/`tanh`, `arcsinh`/`arccosh`/`arctanh`, `expm1`/`exp2`, `log10`/`log2`/`log1p`, `sqrt`/`cbrt`, `power`/`hypot`, `floor`/`ceil`/`trunc`/`rint`, `absolute`). New `tests/test_vecmath` (ULP sweeps + specials + integration); `np::exp`/`sin`/`log` measure 6.4x/7.1x/2.4x vs the scalar ufunc path.
+- **Lens spaces faithful** — `manifold::detail::lens_space_complex(p>=3)` (was an `S³` placeholder): new `moore_zp_complex(p)` mapping-cone of a simplicial degree-`p` circle map (cone + mapping cylinder glued along subcomplexes, `3p+4` vertices) wedged with the `S³` boundary, so `to_simplicial()` is homology-faithful (`H=[Z,Z/p,0,Z]`, Euler 0). `test_manifold` cross-check moved to the agree-table.
+- **Neuromorphic wiring** — `spike::encode_rate` now honors `seed` (Poisson counts + uniform times, deterministic replay, historical `/1000` scale kept); `QuantizedEventArray::as_event_array` really quantizes times to `2^bits` levels; `STDP::apply` accumulates pre/post pairs into a weight and new `PlasticLifBackend` (`NeuromorphicFactory::stdp_lif`, `"STDP-LIF"`) wires it into the event path.
+- **Tensor rank search** — `alpha_evolve::optimizer::search` runs a real deterministic hill-climb over `<2,2,2>` factors from exact Strassen tables (error = max deviation from the multiplication tensor, `0` exact); sizes without an exact kernel report `error = inf` instead of a bogus `0`.
+
+### Fixed
+- **Stub cleanup (breaking)** — removed the last two `*_stub` compatibility aliases, both unused in-repo and superseded by real implementations: `np::einsum_path_stub` (use `np::einsum_path` / `np::linalg::einsum_path` from `linalg.hpp`) and `np::pqc::pqc_kem_encaps_stub` (use `np::pqc::pqc_kem_encaps`). `other.hpp` no longer includes `linalg.hpp` (IWYU). No `*_stub` entry points remain in compiled code.
+- **E8 lattice basis** — `LatticeFactory::e8()` spanned an index-2 sublattice (det −2), not E8: with A7 simple roots fixed, any 8th E8 vector gives det = |Σv| ≥ 2. Replaced with Bourbaki simple roots (det −1, all 240 roots verified in span by `test_lattice.cpp`).
+- **SIMD detection** — `simd.hpp` used an `elif` chain that defined only the top ISA macro, silently disabling all SSE2 kernels on standard `-msse4.2`/AVX builds; detection is now cumulative (also fixes `Features::has_sse2` reporting).
+- **Windows compatibility** — `physics.hpp`/`test_physics.cpp`/`examples/physics_extended.cpp`: `M_PI` (absent from MSVC `<cmath>` without `_USE_MATH_DEFINES`) replaced with `std::numbers::pi`; `bitwise.hpp`: `__builtin_popcount*` (GCC/Clang-only, plus LLP64-fragile `unsigned long` branch) replaced with `std::popcount` from `<bit>`. CMake MSVC block: `/Zc:__cplusplus` (abi.hpp `static_assert`s on `__cplusplus`), `/utf-8` (non-ASCII source), `/W4` under `NP_WERROR` (`/WX` pending a green Windows run). New `windows` CI job (`windows-latest`, MSVC Release, full `ctest`). Surveyed the rest: `dlopen`/`madvise`/`mlock`/`sysconf`/`pthread` already `_WIN32`/`__linux__`-guarded (`gpu.hpp`, `cuda.hpp`, `pqc.hpp`, `threadpool.hpp`, `memory.hpp`, `powerful.hpp`), SIMD detection is `_M_X64`-aware, `io.hpp` is LLP64-aware (`sizeof(long)` branches), no `__int128`/`cpuid.h`/`strcpy`/`PATH_MAX` uses.
 
 ### Fixed
-- **Docs honesty** — `README.md` no longer claims `0 stubs` or bare `Loihi2/SpiNNaker`, `HBM/CXL`, `Hopper/AMX` backends: `neuromorphic` is CPU LIF simulation, `memory` is host storage with `HbmHintArray`/`CxlHintArray` placement hints (`memory.hpp:104-176`), `tensor` is blocked-CPU/FP32-GPU dispatch with quantize-around-FP32 (`tensor_core.hpp:22`), `accelerator` is CPU/GPU/ReRAM-sim (`accelerator.hpp:226-242`). Documented `other.hpp` parity shims and default PQC wrappers as intentional stubs; test count corrected to `49/49` across `README.md`, `docs/` and CI step name.
+- **Docs honesty** — `README.md` no longer claims `0 stubs` or bare `Loihi2/SpiNNaker`, `HBM/CXL`, `Hopper/AMX` backends: `neuromorphic` is CPU LIF simulation, `memory` is host storage with `HbmHintArray`/`CxlHintArray` placement hints (`memory.hpp:104-176`), `tensor` is blocked-CPU/FP32-GPU dispatch with quantize-around-FP32 (`tensor_core.hpp:22`), `accelerator` is CPU/GPU/ReRAM-sim (`accelerator.hpp:226-242`). Documented `other.hpp` parity shims and default PQC wrappers as intentional stubs; test count corrected to `52/52` across `README.md`, `docs/` and CI step name.
 - **CI enforcement** — `lint` job is now blocking (`clang-tidy` warnings fail the build), new `clang-format --check` job enforces `.clang-format` (`ColumnLimit: 120`, 4-space), TSan keeps `NP_WERROR=ON` (warnings-as-errors stay on where races hide).
 - **Error handling (AGENTS.md §4)** — narrowed `datetime64_from_string` catch to `const std::exception&` with rethrow as `invalid_argument`; documented the `datetime_data` count fallback and the `cuda.hpp` `noexcept` cache fallback so no `catch (...)` silently swallows.
 

CMakeLists.txt

@@ -9,10 +9,11 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+# Treat warnings as errors in CI (ALLOW opt-out via NP_WERROR=OFF)
+option(NP_WERROR "Treat warnings as errors" ON)
 if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     add_compile_options(-Wall -Wextra -Wpedantic)
     # Treat warnings as errors in CI (ALLOW opt-out via NP_WERROR=OFF)
-    option(NP_WERROR "Treat warnings as errors" ON)
     if(NP_WERROR)
         add_compile_options(-Werror)
         # Allowlist: intentional parity shims and low-risk warnings (fix incrementally)
@@ -52,6 +53,19 @@ if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     endif()
 endif()
 
+if(MSVC)
+    # /Zc:__cplusplus reports the true language version (abi.hpp static_asserts
+    # __cplusplus >= 202002L; without it MSVC reports 199711L).
+    # /utf-8 keeps non-ASCII source (→, ⊕, Λ, ε) intact under all locales.
+    add_compile_options(/Zc:__cplusplus /utf-8)
+    # /W4 for parity with -Wall -Wextra -Wpedantic. /WX stays off on MSVC
+    # until the Windows CI job proves the tree warning-clean there (C4996
+    # deprecation notes etc. are warnings, not errors, without /WX).
+    if(NP_WERROR)
+        add_compile_options(/W4)
+    endif()
+endif()
+
 # SIMD optimization options
 option(NP_ENABLE_SIMD "Enable SIMD optimizations (SSE2/AVX/AVX2/AVX-512/NEON)" ON)
 option(NP_ENABLE_AVX2 "Enable AVX2 instructions (implies AVX)" OFF)
@@ -96,7 +110,9 @@ if(NP_ENABLE_SIMD)
                 add_compile_options(/arch:AVX512)
             elseif(NP_ENABLE_AVX2)
                 add_compile_options(/arch:AVX2)
-            else()
+            elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
+                # /arch:SSE2 is x86-only; on x64 SSE2 is the baseline and
+                # the flag warns (D9002). Only pass it for 32-bit builds.
                 add_compile_options(/arch:SSE2)
             endif()
         else()
@@ -238,6 +254,10 @@ endif()
 
 add_library(numpy-cpp INTERFACE)
 add_library(numpy-cpp::numpy-cpp ALIAS numpy-cpp)
+# ABI version: selects inline namespace vN (see include/np/abi.hpp).
+# abi.hpp defaults to 1 and #errors on mismatch, so the build stays in sync.
+set(NP_ABI_VERSION 1 CACHE STRING "numpy-cpp ABI version (inline namespace vN)")
+target_compile_definitions(numpy-cpp INTERFACE NP_ABI_VERSION=${NP_ABI_VERSION})
 target_include_directories(numpy-cpp INTERFACE
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
     $<INSTALL_INTERFACE:include>)

README.md

@@ -7,19 +7,20 @@
 [![Header-only](https://img.shields.io/badge/header--only-Yes-brightgreen?style=flat-square)](include/np/np.hpp)
 [![NumPy](https://img.shields.io/badge/NumPy-2.2-013243.svg?style=flat-square&logo=numpy)](https://numpy.org/doc/stable/)
 [![License](https://img.shields.io/badge/license-BSD--3--Clause-green?style=flat-square)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-49%2F49-brightgreen?style=flat-square)](#testing)
+[![Tests](https://img.shields.io/badge/tests-52%2F52-brightgreen?style=flat-square)](#testing)
 [![SIMD](https://img.shields.io/badge/SIMD-SSE4.2%20%7C%20AVX2%20%7C%20AVX--512%20%7C%20NEON%20%7C%20WASM%20%7C%20RVV-orange?style=flat-square)](#performance)
 
 **numpy-cpp** is a complete, header-only C++20 reimplementation of the NumPy 2.2 API — **760+ routines** across **36 modules**, with NumPy-identical semantics. Include one header, get the whole scientific stack at compiled speed.
 
-> Parity shims: a handful of `numpy.distutils` / `ctypeslib` compat helpers in `other.hpp` are intentional thin stubs (documented in [Known Divergences](#known-divergences)), and optional PQC KEM/signature wrappers default to stubs unless `NP_PQC_ALG` is set. Everything in the NumPy surface above has a real implementation plus scalar fallback.
+> Parity helpers: the `numpy.distutils` / `ctypeslib` compat entries in `other.hpp` are working C++ equivalents (introspection via iostreams, process-wide buffer-size state, path optimization via the real `linalg::einsum_path` optimizer; documented in [Known Divergences](#known-divergences)), and optional PQC KEM/signature wrappers are constant-time integration points unless `NP_PQC_ALG` selects a backend. Everything in the NumPy surface above has a real implementation plus scalar fallback.
 
 ```cpp
 #include <np/np.hpp> // now fully integrated (random + concatenate included)
+#include <numbers>
 
 int main() {
   auto a = np::arange<double>(0, 10, 0.5); // [0, 0.5, …, 9.5]
-  auto b = np::linspace<double>(0, 2 * M_PI, 100);
+  auto b = np::linspace<double>(0, 2 * std::numbers::pi, 100);
   auto y = np::sin(b); // ufunc, SIMD-dispatched
 
   auto M = np::eye<double>(3);
@@ -68,7 +69,7 @@ No linking. No Python runtime. No code generation. Just `#include <np/np.hpp>`.
 * **Zero-overhead** — header-only `INTERFACE` library (`cmake --install` just copies headers). Views are `shared_ptr` aliases, not copies. Contiguous fast paths use `memcpy` / direct `T* __restrict`.
 * **Portable SIMD** — auto-detected: SSE4.2 / AVX2 / AVX-512 on x86-64, NEON on ARM64, WASM SIMD128, RISC-V Vector, POWER VSX. Scalar fallback always correct.
 * **Two array engines** — `ndarray<T>` (dynamic, heap) + `ndarrayf<T, Extents...>` (fixed, stack, `constexpr`-foldable).
-* **Production-ready** — lock-free Chase-Lev threadpool, `49/49` CTest suites, `clang-format` enforced, BSD-3-Clause.
+* **Production-ready** — lock-free Chase-Lev threadpool, `52/52` CTest suites, `clang-format` enforced, BSD-3-Clause.
 
 > If you embed scientific computing in C++ — games, robotics, trading, edge inference — numpy-cpp lets you keep NumPy semantics without shipping Python.
 
@@ -90,7 +91,7 @@ No linking. No Python runtime. No code generation. Just `#include <np/np.hpp>`.
 - **I/O** — `load`, `save`, `savez`, `NpzFile`, `savetxt`, `DataSource`
 - **Polynomial** — `Polynomial`, `Chebyshev`, `polyfit`, `polyutils`
 - **Dtype & Masked** — `can_cast`, `promote_types`, `finfo`/`iinfo`, `MaskedArray`
-- **Extras** — `bigint` (Boost `cpp_int` / GMP), `pqc` constant-time hardening (KEM/signature wrappers are opt-in stubs unless `NP_PQC_ALG` is set), `differential` LLVM JIT (optional, interpreter fallback), `homology`/`homotopy`/`manifold`/`variety`, `lattice`/`padic`, `neuromorphic` (CPU LIF simulation, no Loihi2/SpiNNaker hardware), `memory` (host storage with HBM/CXL placement *hints*, no device migration), `tensor` (blocked-CPU / FP32-GPU dispatch, FP8 is quantize-around-FP32, no Hopper/AMX tile path), `analog` (ReRAM crossbar simulation), `photonics` (Mach-Zehnder unitary math + simulation), `quantum` (in-house state-vector simulation), `accelerator` (heterogeneous CPU/GPU/sim dispatch)
+- **Extras** — `bigint` (Boost `cpp_int` / GMP), `pqc` constant-time hardening (KEM/signature wrappers are opt-in integration points unless `NP_PQC_ALG` is set), `differential` LLVM JIT (optional, interpreter fallback), `homology`/`homotopy`/`manifold`/`variety`, `lattice`/`padic`, `neuromorphic` (CPU LIF simulation, no Loihi2/SpiNNaker hardware), `memory` (host storage with HBM/CXL placement *hints*, no device migration), `tensor` (blocked-CPU / FP32-GPU dispatch, FP8 is quantize-around-FP32, no Hopper/AMX tile path), `analog` (ReRAM crossbar simulation), `photonics` (Mach-Zehnder unitary math + simulation), `quantum` (in-house state-vector simulation), `accelerator` (heterogeneous CPU/GPU/sim dispatch)
 
 ---
 
@@ -178,6 +179,7 @@ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DNP_ENABLE_AVX2=ON -DNP_ENABLE_L
 #include <np/random.hpp>
 #include <np/linalg.hpp> // explicit for linalg if needed
 #include <iostream>
+#include <numbers>
 
 int main() {
   // — Creation & arithmetic (broadcasting) —
@@ -198,7 +200,7 @@ int main() {
 
   // — FFT —
   auto t = np::linspace<double>(0, 1, 64);
-  auto sig = np::sin(t * (2 * M_PI * 5));
+  auto sig = np::sin(t * (2 * std::numbers::pi * 5));
   auto F = np::fft::rfft(sig);
 
   // — Datetime (week arithmetic, O(1)) —
@@ -342,7 +344,7 @@ tests/                49 CTest suites + bench_math / bench_hardware (AVX, manual
 
 ```bash
 cmake -S . -B build && cmake --build build -j8
-ctest --test-dir build --output-on-failure   # 49/49
+ctest --test-dir build --output-on-failure   # 52/52
 
 #single suite verbose
 ./build/tests/test_ndarray --verbose
@@ -353,7 +355,7 @@ g++ -std=c++20 -I include tests/test_math.cpp -o /tmp/t && /tmp/t
 cmake --build build --target bench_math && ./build/tests/bench_math
 ```
 
-CI target is `49/49` green. Every fast path has a scalar fallback exercised by tests.
+CI target is `52/52` green. Every fast path has a scalar fallback exercised by tests.
 
 ---
 
@@ -391,7 +393,7 @@ See [`docs/CONTRIBUTING.md`](docs/CONTRIBUTING.md) and `AGENTS.md`.
 * `operator[](i,j)` is C++23 — use `arr(i,j)` or `arr[i][j]` proxy (`ndarray.hpp:3315`).
 * Complex `linalg` is real-only (`is_complex_v` static-assert) — dispatches to real `double`.
 * `ndarray<bool>` uses proxy reference (`vector<bool>` bitset); `is_contiguous()` aware.
-* `numpy.distutils` / `ctypeslib` are thin `other.hpp` stubs (`who`, `disp`, `info`, `source`, `lookfor`, `deprecate`, `show_config`, buffer-size helpers) plus `einsum_path_stub` (real path logic lives in `linalg.hpp`). PQC KEM/signature wrappers are opt-in stubs unless `NP_PQC_ALG` selects a backend.
+* `numpy.distutils` / `ctypeslib` are working `other.hpp` equivalents (`who`, `disp`, `info`, `source`, `lookfor`, `deprecate`, `show_config`, process-wide buffer-size state); path optimization lives in `linalg.hpp` as `np::einsum_path` / `np::linalg::einsum_path`. PQC KEM/signature wrappers are opt-in integration points unless `NP_PQC_ALG` selects a backend.
 
 ---
 

docs/API.md

@@ -32,7 +32,7 @@ Umbrella `include/np/np.hpp:13` (28 includes; all integrated). Every `np::` has
 | **Exceptions** | `exceptions.hpp` | `LinAlgError, AxisError` | `routines.exceptions.html` |
 | **Window** | `window.hpp` | `bartlett, kaiser` | `routines.window.html` |
 | **Testing** | `testing.hpp:108` | `assert_equal, Tester:442` | `routines.testing.html` |
-| **Other** | `other.hpp:119` | `who, byte_bounds, einsum_path_stub` | `routines.other.html` |
+| **Other** | `other.hpp:119` | `who, byte_bounds` (+ `einsum_path` via `linalg.hpp`) | `routines.other.html` |
 | **Threadpool** | `threadpool.hpp:236` | `ThreadPool::global().parallel_for` | `threadpool` |
 | **BigInt** | `bigint.hpp:304` | `bigint (cpp_int/GMP), make_bigint, _mpz` | `—` |
 | **Homology** | `homology.hpp:539` | `SimplicialComplex, betti_numbers, homology_groups, smith_normal_form, exact_rank` | `Hatcher` |
@@ -55,7 +55,7 @@ Umbrella `include/np/np.hpp:13` (28 includes; all integrated). Every `np::` has
 | **Persistent** | `persistent.hpp:94` | `FilteredSimplex, Filtration, persistence_barcode, bottleneck_distance, vietoris_rips` | `Edelsbrunner–Harer` |
 | **Spectral** | `spectral.hpp:129` | `MayerVietoris, SpectralSequence, leray_serre (Hopf), ahss, total_betti` | `McCleary` |
 
-Count `712` base + ~50 higher-math (homology/bundle/persistent/spectral) + aliases. `other.hpp` parity shims (`who/disp/info/source/lookfor/deprecate/show_config`, `einsum_path_stub`) and default PQC KEM/signature wrappers are intentional documented stubs.
+Count `712` base + ~50 higher-math (homology/bundle/persistent/spectral) + aliases. `other.hpp` parity helpers (`who/disp/info/source/lookfor/deprecate/show_config`, process-wide buffer-size state) and the `einsum_path` optimizer (`linalg.hpp`) plus default PQC KEM/signature integration points are working, documented equivalents.
 
 ## Quick reference