quant-kernel 2.9.0__tar.gz

quant_kernel-2.9.0/.clang-format

@@ -0,0 +1,3 @@
+BasedOnStyle: Google
+IndentWidth: 4
+ColumnLimit: 100

quant_kernel-2.9.0/.github/workflows/ci.yml

@@ -0,0 +1,128 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - "**"
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.1.7
+        with:
+          persist-credentials: false
+
+      - name: Setup Python
+        uses: actions/setup-python@v5.1.0
+        with:
+          python-version: "3.11"
+
+      - name: Install Python dependencies
+        run: python -m pip install --upgrade pip && python -m pip install -r requirements.txt
+
+      - name: Run API parity guard checks
+        env:
+          PYTHONPATH: python
+        run: |
+          python -m pytest -q python/tests/test_parity_guard.py
+
+      - name: Build C++ library
+        run: make build
+
+      - name: Run C++ unit tests
+        run: make test-cpp
+
+      - name: Run Python tests
+        run: make test-py
+
+      - name: Run deterministic batch/perf regression tests
+        env:
+          PYTHONPATH: python
+          QK_LIB_PATH: ${{ github.workspace }}/build/cpp
+          PYTHONHASHSEED: "0"
+          OMP_NUM_THREADS: "1"
+        run: |
+          python -m pytest -q python/tests/test_batch_api.py python/tests/test_perf_regression.py
+
+      - name: Generate benchmark comparison table
+        env:
+          PYTHONPATH: python
+          QK_LIB_PATH: ${{ github.workspace }}/build/cpp
+          PYTHONHASHSEED: "0"
+          OMP_NUM_THREADS: "1"
+        run: |
+          cmake --build build -j 4 --target qk_bench_bsm_batch
+          python python/examples/benchmark_scalar_batch_cpp.py --n 50000 --repeats 3 | tee benchmark_table.md
+          cat benchmark_table.md >> "${GITHUB_STEP_SUMMARY}"
+
+      - name: Configure fuzz tests
+        run: cmake -S fuzztest -B build/fuzztest
+
+      - name: Build fuzz test binaries
+        run: cmake --build build/fuzztest -j 4
+
+      - name: Run all fuzz test suites under fuzztest/
+        timeout-minutes: 15
+        shell: bash
+        env:
+          FUZZTEST_PRNG_SEED: NNMQpT7FLDG9rOgxXhD87HtvjqCtE-6NHWnDn00xICI
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          sources=(fuzztest/fuzz_*.cpp)
+          if (( ${#sources[@]} == 0 )); then
+            echo "No fuzz sources found under fuzztest/"
+            exit 1
+          fi
+          for src in "${sources[@]}"; do
+            bin="$(basename "${src%.cpp}")"
+            exe="./build/fuzztest/${bin}"
+            echo "Running ${exe}"
+            if [[ ! -x "${exe}" ]]; then
+              echo "Expected fuzz binary not found: ${exe}"
+              exit 1
+            fi
+            "${exe}"
+          done
+
+      - name: Build wheel (packaging check)
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build --wheel
+
+      - name: Validate wheel metadata
+        run: |
+          python -m pip install --upgrade twine
+          python -m twine check dist/*
+
+      - name: Install built wheel and run end-user smoke test
+        run: |
+          python -m pip install --force-reinstall dist/*.whl
+          python - <<'PY'
+          import numpy as np
+          from quantkernel import QuantKernel, QK_CALL, QK_PUT
+
+          qk = QuantKernel()
+          bsm = qk.black_scholes_merton_price(100.0, 100.0, 1.0, 0.2, 0.03, 0.01, QK_CALL)
+          am = qk.crr_price(100.0, 100.0, 1.0, 0.2, 0.03, 0.01, QK_PUT, 200, 1)
+          heston = qk.heston_price_cf(100.0, 100.0, 1.0, 0.03, 0.01, 0.04, 2.0, 0.04, 0.5, -0.7, QK_CALL, 512, 100.0)
+          batch = qk.black_scholes_merton_price_batch(
+              np.array([100.0, 101.0]),
+              np.array([100.0, 100.0]),
+              np.array([1.0, 1.0]),
+              np.array([0.2, 0.2]),
+              np.array([0.03, 0.03]),
+              np.array([0.01, 0.01]),
+              np.array([QK_CALL, QK_PUT], dtype=np.int32),
+          )
+          assert bsm > 0.0 and am > 0.0 and heston > 0.0 and batch.shape == (2,)
+          print("Wheel smoke test passed.")
+          PY

quant_kernel-2.9.0/.github/workflows/wheels.yml

@@ -0,0 +1,81 @@
+name: Wheels
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  build-sdist:
+    name: Build sdist
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Build sdist
+        run: pip install build && python -m build --sdist
+
+      - name: Upload sdist artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  build-wheels:
+    name: Build wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-14]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.23.3
+        env:
+          CIBW_OUTPUT_DIR: wheelhouse
+
+      - name: Upload wheel artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  publish-pypi:
+    name: Publish to PyPI
+    needs: [build-sdist, build-wheels]
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    environment:
+      name: "pypi"
+      url: https://pypi.org/p/quant-kernel
+
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "{sdist,wheels-*}"
+          path: dist
+          merge-multiple: true
+
+      - name: Publish wheels
+        uses: pypa/gh-action-pypi-publish@release/v1

quant_kernel-2.9.0/.gitignore

@@ -0,0 +1,41 @@
+build/
+cmake-build-*/
+__pycache__/
+*.pyc
+.pytest_cache/
+*.egg-info/
+dist/
+wheelhouse/
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+.claude
+target/
+rust/runtime/target/
+rust/runtime/target_local/
+rust/runtime/.tmp/
+third_party_source/
+
+fuzztest/fuzztest/
+# Editor / OS local files
+.vscode/
+.idea/
+.DS_Store
+*.swp
+*.swo
+claude_session.txt
+# Python local environments / coverage
+.venv/
+venv/
+.env
+.env.*
+.ipynb_checkpoints/
+.mypy_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+
+compile_commands.json
+python/quantkernel/_native_batch.cpp
+python/quantkernel/_native_batch*.so

quant_kernel-2.9.0/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+project(QuantKernel LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+option(QK_BUILD_TESTS "Build C++ tests" ON)
+option(QK_BUILD_BENCHMARKS "Build C++ benchmarks" ON)
+
+if(QK_BUILD_TESTS)
+  enable_testing()
+endif()
+
+add_subdirectory(cpp)

quant_kernel-2.9.0/LICENSE

@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.

quant_kernel-2.9.0/Makefile

@@ -0,0 +1,68 @@
+SHELL := /bin/bash
+
+BUILD_DIR ?= build
+CMAKE ?= cmake
+PYTHON ?= python3
+PYTEST ?= pytest
+JOBS ?= $(shell nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
+
+.DEFAULT_GOAL := quick
+
+.PHONY: help configure build build-wheel bench test-cpp test-py test demo quick clean clean-fuzz clean-caches clean-all clean-venv
+
+help:
+	@echo "Targets:"
+	@echo "  make quick         # Configure, build, C++ tests, Python tests"
+	@echo "  make build         # Configure + C++ build"
+	@echo "  make build-wheel   # Build Python wheel (platform-specific)"
+	@echo "  make bench         # Run scalar/batch benchmark table script"
+	@echo "  make test          # Run C++ and Python tests"
+	@echo "  make demo          # Run Python demo (direct kernel path)"
+	@echo "  make clean         # Remove build artifacts"
+	@echo "  make clean-fuzz    # Remove fuzztest build artifacts"
+	@echo "  make clean-caches  # Remove local caches (pycache/pytest/compile_commands)"
+	@echo "  make clean-all     # clean + clean-fuzz + clean-caches"
+	@echo "  make clean-venv    # Remove local .venv"
+
+configure:
+	$(CMAKE) -S . -B $(BUILD_DIR) -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+
+build: configure
+	$(CMAKE) --build $(BUILD_DIR) -j $(JOBS)
+
+build-wheel:
+	$(PYTHON) -m pip wheel . --no-deps -w dist
+
+bench: build
+	PYTHONPATH=python QK_LIB_PATH="$(CURDIR)/$(BUILD_DIR)/cpp" $(PYTHON) python/examples/benchmark_scalar_batch_cpp.py --n 50000 --repeats 3
+
+test-cpp: build
+	ctest --test-dir $(BUILD_DIR) --output-on-failure
+
+test-py: build
+	PYTHONPATH=python QK_LIB_PATH="$(CURDIR)/$(BUILD_DIR)/cpp" $(PYTEST) -q python/tests
+
+test: test-cpp test-py
+
+demo: build
+	PYTHONPATH=python $(PYTHON) python/examples/demo_pricing.py
+
+quick: test
+
+clean:
+	$(CMAKE) -E rm -rf $(BUILD_DIR)
+	$(CMAKE) -E rm -rf target
+
+clean-fuzz:
+	$(CMAKE) -E rm -rf fuzztest/build
+	$(CMAKE) -E rm -rf fuzztest/dist
+
+clean-caches:
+	$(CMAKE) -E rm -rf .pytest_cache
+	find python -type d -name __pycache__ -prune -exec rm -rf {} +
+	$(CMAKE) -E rm -f compile_commands.json
+
+clean-all: clean clean-fuzz clean-caches
+
+clean-venv:
+	$(CMAKE) -E rm -rf .venv

quant_kernel-2.9.0/PKG-INFO

@@ -0,0 +1,304 @@
+Metadata-Version: 2.1
+Name: quant-kernel
+Version: 2.9.0
+Summary: High-performance derivative pricing engine with 40+ algorithms
+Keywords: quant,options,pricing,derivatives,finance,hpc
+Author: QuantKernel Contributors
+License:            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                           Version 2, December 2004
+        
+        Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+        
+        Everyone is permitted to copy and distribute verbatim or modified
+        copies of this license document, and changing it is allowed as long
+        as the name is changed.
+        
+                   DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+          TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+        
+         0. You just DO WHAT THE FUCK YOU WANT TO.
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Project-URL: Homepage, https://github.com/yluoc/Quant-Kernel
+Project-URL: Repository, https://github.com/yluoc/Quant-Kernel
+Project-URL: Issues, https://github.com/yluoc/Quant-Kernel/issues
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.24
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: cibuildwheel>=2.23.0; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: cupy>=12.0; extra == "gpu"
+Provides-Extra: dev
+Provides-Extra: gpu
+Description-Content-Type: text/markdown
+
+# QuantKernel
+
+QuantKernel is a C++17 quantitative pricing kernel with Python bindings.
+It focuses on fast scalar and batch option analytics across closed-form, lattice,
+finite-difference, Monte Carlo, Fourier, quadrature, regression-approximation,
+Greek-estimation, and ML-inspired methods.
+
+Linux, macOS, and Windows are supported.
+
+## Scope
+
+QuantKernel provides:
+- C++ shared library (`libquantkernel.so` / `libquantkernel.dylib` / `libquantkernel.dll`) with C ABI exports.
+- Python package (`quantkernel`) with scalar and batch methods.
+- Optional Python-level accelerator (`QuantAccelerator`) for backend selection (`auto`, `cpu`, `gpu`).
+
+## Install (Not available yet, more test needed)
+
+End users (recommended):
+
+```bash
+python -m pip install --upgrade pip
+python -m pip install quant-kernel
+```
+
+This installs a prebuilt wheel on supported platforms and does not require local C++ compilation.
+
+## Implemented Algorithm Families
+
+### Closed-form / Semi-analytical
+- Black-Scholes-Merton
+- Black-76
+- Bachelier
+- Heston characteristic-function pricing
+- Merton jump-diffusion
+- Variance-Gamma characteristic-function pricing
+- SABR (Hagan lognormal IV + Black-76 pricing)
+- Dupire local volatility inversion
+
+### Tree / Lattice
+- CRR
+- Jarrow-Rudd
+- Tian
+- Leisen-Reimer
+- Trinomial tree
+- Derman-Kani style local-vol tree entrypoints:
+  - Constant local vol surface (`derman_kani_const_local_vol_price`)
+  - Vanilla call-surface driven entrypoint (`derman_kani_call_surface_price`)
+
+### Finite Difference
+- Explicit FD
+- Implicit FD
+- Crank-Nicolson
+- ADI (Douglas, Craig-Sneyd, Hundsdorfer-Verwer)
+- PSOR
+
+### Monte Carlo
+- Standard Monte Carlo
+- Euler-Maruyama
+- Milstein
+- Longstaff-Schwartz
+- Quasi Monte Carlo (Sobol, Halton)
+- Multilevel Monte Carlo
+- Importance Sampling
+- Control Variates
+- Antithetic Variates
+- Stratified Sampling
+
+### Fourier Transform Methods
+- Carr-Madan FFT
+- COS (Fang-Oosterlee)
+- Fractional FFT
+- Lewis Fourier inversion
+- Hilbert transform pricing
+
+### Integral Quadrature
+- Gauss-Hermite
+- Gauss-Laguerre
+- Gauss-Legendre
+- Adaptive quadrature
+
+### Regression Approximation
+- Polynomial Chaos Expansion
+- Radial Basis Functions
+- Sparse Grid Collocation
+- Proper Orthogonal Decomposition
+
+### Greeks / Adjoint Methods
+- Pathwise derivative delta
+- Likelihood ratio delta
+- AAD delta
+
+### Machine-learning Inspired Pricing
+- Deep BSDE
+- PINNs
+- Deep Hedging
+- Neural SDE calibration
+
+## Repository Layout
+
+- `cpp/`
+  - `include/quantkernel/qk_api.h`: C API declarations
+  - `src/`: implementations and API bridge (`qk_api.cpp`)
+  - `tests/`: C++ test executables
+- `python/`
+  - `quantkernel/`: Python API (`QuantKernel`, `QuantAccelerator`)
+  - `tests/`: pytest suite
+  - `examples/`: usage and benchmark scripts
+- `Makefile`: common build/test commands
+
+## Requirements
+
+- CMake >= 3.14
+- C++17 compiler
+- Python >= 3.11
+- NumPy
+
+Optional:
+- CuPy (for GPU backend in accelerator paths)
+
+## Build
+
+From project root:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install --upgrade pip
+python3 -m pip install -r requirements.txt
+
+cmake -S . -B build
+cmake --build build -j
+```
+
+## Python Setup (from source checkout)
+
+Point Python to the package and shared library:
+
+```bash
+export PYTHONPATH=$PWD/python
+export QK_LIB_PATH=$PWD/build/cpp
+```
+
+Then use:
+
+```python
+from quantkernel import QuantKernel, QK_CALL
+
+qk = QuantKernel()
+price = qk.black_scholes_merton_price(
+    100.0, 100.0, 1.0, 0.2, 0.03, 0.01, QK_CALL
+)
+print(price)
+```
+
+## Batch Usage
+
+```python
+import numpy as np
+from quantkernel import QuantKernel, QK_CALL, QK_PUT
+
+qk = QuantKernel()
+n = 100_000
+rng = np.random.default_rng(42)
+
+spot = rng.uniform(80.0, 120.0, n)
+strike = rng.uniform(80.0, 120.0, n)
+t = rng.uniform(0.25, 2.0, n)
+vol = rng.uniform(0.1, 0.6, n)
+r = rng.uniform(0.0, 0.08, n)
+q = rng.uniform(0.0, 0.04, n)
+option_type = np.where((np.arange(n) & 1) == 0, QK_CALL, QK_PUT).astype(np.int32)
+
+prices = qk.black_scholes_merton_price_batch(spot, strike, t, vol, r, q, option_type)
+print(prices[:3])
+```
+
+## Derman-Kani Call-Surface API (Python)
+
+`derman_kani_call_surface_price` accepts:
+- `surface_strikes`: 1D strikes
+- `surface_maturities`: 1D maturities
+- `surface_call_prices`:
+  - 2D array with shape `(len(surface_maturities), len(surface_strikes))`, or
+  - flattened 1D array of that size
+
+Example:
+
+```python
+from quantkernel import QuantKernel, QK_CALL
+
+qk = QuantKernel()
+spot, r, q = 100.0, 0.03, 0.01
+surface_strikes = [80, 90, 100, 110, 120]
+surface_maturities = [0.5, 1.0, 1.5]
+
+# Synthetic surface here; in production use observed call prices.
+surface_call_prices = [
+    [qk.black_scholes_merton_price(spot, k, tau, 0.2, r, q, QK_CALL) for k in surface_strikes]
+    for tau in surface_maturities
+]
+
+price = qk.derman_kani_call_surface_price(
+    spot=spot,
+    strike=100.0,
+    t=1.0,
+    r=r,
+    q=q,
+    option_type=QK_CALL,
+    surface_strikes=surface_strikes,
+    surface_maturities=surface_maturities,
+    surface_call_prices=surface_call_prices,
+    steps=20,
+)
+print(price)
+```
+
+If `QK_LIB_PATH` is unset, the package also searches for a bundled shared library from an installed wheel.
+
+## Testing
+
+From project root:
+
+```bash
+make test-cpp
+make test-py
+# or
+make quick
+```
+
+Direct commands:
+
+```bash
+ctest --test-dir build --output-on-failure
+PYTHONPATH=python QK_LIB_PATH=build/cpp pytest -q python/tests
+```
+
+## Benchmark
+
+```bash
+PYTHONPATH=python QK_LIB_PATH=build/cpp \
+python3 python/examples/benchmark_scalar_batch_cpp.py --n 50000 --repeats 3
+```
+
+## Error Handling
+
+### C API
+- Batch functions return ABI error codes (`QK_OK`, `QK_ERR_NULL_PTR`, `QK_ERR_BAD_SIZE`, `QK_ERR_INVALID_INPUT`, etc.).
+- Use `qk_get_last_error()` for thread-local error detail.
+
+### Python API
+- Raises typed exceptions:
+  - `QKError`
+  - `QKNullPointerError`
+  - `QKBadSizeError`
+  - `QKInvalidInputError`
+
+## License
+
+`LICENSE` (WTFPL).