walkforward 3.4.0__tar.gz

walkforward-3.4.0/.gitattributes

@@ -0,0 +1,3 @@
+# Verification tooling, not part of the library: keep GitHub's language
+# statistics honest about what mlrisk is
+tests/reference/** linguist-detectable=false

walkforward-3.4.0/.gitignore

@@ -0,0 +1,28 @@
+# Build
+build/
+build-*/
+out/
+cmake-build-*/
+CMakeCache.txt
+CMakeFiles/
+Testing/
+compile_commands.json
+
+# Compiled
+*.o
+*.obj
+*.a
+*.lib
+*.so
+*.dylib
+*.dll
+*.exe
+*.pdb
+*.dSYM/
+
+# IDE / OS
+.vscode/
+.idea/
+.vs/
+*.swp
+.DS_Store

walkforward-3.4.0/CHANGELOG.md

@@ -0,0 +1,372 @@
+# Changelog
+
+## 3.4.0 (2026-09-04)
+
+First release published to PyPI as `walkforward`. The C library is unchanged
+from 3.3.1; everything here is the Python package and the machinery to ship
+it. Publishing uses a PyPI API token rather than trusted publishing, because
+GitHub issues this repository an OIDC subject claim carrying numeric owner and
+repository identifiers that PyPI does not match; `RELEASING.md` has the
+detail.
+
+### Added
+
+- A Python package, `walkforward`, in `python/`. It binds this library with
+  ctypes and numpy: `ewma_vol`, `garch_fit` returning a `GarchModel` with
+  `persistence`, `half_life` and `unconditional_vol`, the rolling statistics
+  with a `lag` helper, the sizing functions, `Ridge`, and
+  `PurgedWalkForward`, a scikit-learn cross-validator.
+- Two API decisions worth naming. The splitter asks for `label_horizon`
+  rather than a purge count, because `purge = h - 1` is the part users get
+  wrong, and it has no `embargo` argument, because a walk-forward never
+  trains on data after the window it is testing. `walk_forward_splits`
+  exposes the post-training variant for people who want it.
+- The binding allocates every output buffer itself, so the `restrict`
+  non-aliasing contract on the C outputs cannot be violated by a numpy view,
+  and a pandas Series keeps its index through a call.
+- Wheels are `py3-none`: the binding never touches the Python C API, so one
+  wheel per platform serves every Python 3.
+- A `python-package` CI job builds and tests the wheel on Linux, macOS and
+  Windows, asserts the package and the library it bundles report the same
+  version, and installs from a source distribution in a clean directory so
+  the sdist keeps carrying the C it has to compile.
+- The Python packaging sits at the repository root rather than in `python/`,
+  because a source distribution has to contain `src/` and `include/` and
+  those cannot be reached from a subdirectory.
+- A `Release` workflow that builds the sdist and five wheels (Linux x86-64
+  and aarch64, macOS Intel and Apple silicon, Windows x64), tests each wheel
+  on the platform it was built for, installs the sdist from scratch, and
+  publishes to PyPI through trusted publishing, with no API token in the
+  repository. A tag that disagrees with the version in `CMakeLists.txt` is
+  refused before anything is built. See `RELEASING.md`.
+  Validated by running the workflow before any tag: it produces one
+  `py3-none` wheel per platform, each carrying its own shared library, and
+  the Linux wheels need only glibc 2.17 so they install anywhere numpy does.
+
+### Changed
+
+- The README is rewritten around the Python package, which is how most people
+  will use this, with the C library as its own section rather than the
+  headline. Every measured number is carried over, and both Python snippets
+  in it are executed as part of the checks.
+- The repository is now `haeganm/walkforward`, matching the Python package.
+  GitHub redirects the old address and the earlier releases are unaffected.
+  The C keeps its `mlr_` prefix and its `include/mlrisk/` headers, the way
+  Pillow ships `PIL`.
+
+
+## 3.3.1 (2026-09-04)
+
+- `mlr_drawdown_scale` is contemporaneous (`scale[t]` uses the close at the
+  end of period `t`) and its header said "multiply position sizes by
+  scale_out" with no lag, in the same file whose timing contract says index
+  `t` must not know period `t`. Applying `scale[t]` to the position held
+  over period `t` de-levers on the bar of a loss using that bar's own close.
+  The header, the sizing contract and the README now say to use
+  `scale[t-1]`; a test pins the alignment. No code change.
+- The rolling mean and standard deviation shifted every value by the first
+  finite value of the whole series and never revisited that choice. A bad
+  first tick therefore corrupted every later window: with prices near 100
+  and a first value of 1e9, windows that did not even contain it had a
+  standard deviation 600% off and a mean off by 1e-6; a first value of 1e12
+  made the std meaningless. A long trend away from the starting level eroded
+  precision the same way. The offset now comes from inside the current
+  window, the accumulators are rebuilt every `window` samples (amortized
+  O(1)) and whenever a leaving sample carried almost all of the variance or
+  the sum, so an outlier that has left leaves no rounding behind. Measured
+  against exact rational arithmetic: 6e-16 relative for the std and an exact
+  mean after first ticks of 1e9, 1e12 and 1e15 and along a trend from 100
+  to 1e6. Cost: about 6 ns per element for the mean and 20 for the std,
+  up from 4 and 15.
+- `mlr_linreg_fit` centered each feature with a plain running sum, so a
+  feature at a large level carried rounding of order n * eps * level into
+  every centered value: with a price column near 1e9 and unit variation
+  the slope was off by 4e-12, and at 1e12 by 7e-7, while an SVD solve
+  reached 1e-15. Columns are now shifted by the first row before centering
+  (differences of nearby doubles are exact), which puts the slope at 4e-15
+  from 1e6 to 1e15, ahead of scikit-learn's 1.7e-5 at 1e15.
+- The rolling mean returned `Inf` and the rolling std returned `0` with
+  `MLR_OK` for a window of finite values whose differences overflow (values
+  of opposite sign near 1e308): the shifted accumulators overflowed and the
+  `fmax` that guards an epsilon-negative variance turned the resulting NaN
+  into a zero standard deviation. Such windows are now NaN, the state is
+  rebuilt on the next step, and no output is ever Inf.
+- `mlr_garch_fit` documented `MLR_EDOMAIN` for a denormally small variance
+  but only rejected zero; at a backcast of 4e-321 it returned `MLR_OK` with
+  alpha drifted by 0.003 and `converged = 0`. Variances below `DBL_MIN` are
+  now refused as documented; anything above fits to the same parameters as
+  the unscaled series.
+- `mlr_kelly_fraction` returned `f = 0` with `MLR_OK` when the squared
+  deviations overflowed (variance `Inf`), a silently rounded estimate where
+  the same function already refuses the NaN form of the overflow. It now
+  returns `MLR_EDOMAIN`.
+
+
+## 3.3.0 (2026-09-04)
+
+The last pass before the C API is frozen for language bindings. Three
+reviewers who had not seen the code read it; nine of their findings
+reproduced and are fixed here.
+
+### Fixed
+
+- The GARCH recursion was written three ways: the likelihood and the fit's
+  `sigma2_next` loop as `omega + alpha*r*r + beta*s2`, the filter as
+  `omega + alpha*(r*r) + beta*s2`. The two differ by an ulp on about a third
+  of steps, so for 12% of fit samples `sigma2_next` was not the value the
+  filter reached and the documented bit-exact `mlr_garch_filter_from`
+  continuation failed by an ulp. One `garch_step` now serves all three;
+  the continuation is tested across 60 fits.
+- `mlr_garch_forecast` accepted `sigma2_next == 0` (the value in a
+  hand-built model that never set it) and forecast zero volatility with
+  `MLR_OK`. Now `MLR_EINVAL`, matching `mlr_garch_filter_from`.
+- `mlr_linreg_fit` wrote weights into the model during back-substitution
+  and the intercept before checking it, so a failing fit left a half-new
+  model behind. It now solves into scratch and touches the model only on
+  success; the header says "on any failure the model is left exactly as it
+  was".
+- `mlr_linreg_predict` on a model that was initialized but never fitted
+  returned all zeros with `MLR_OK`. `mlr_lin_model` gained a `fitted` field
+  (set by a successful fit, cleared by init and free) and predict requires
+  it. Recompile consumers: the struct grew.
+- The installed `mlrisk.pc` located the prefix as `${pcfiledir}/../..`,
+  which is wrong when `CMAKE_INSTALL_LIBDIR` is two levels deep
+  (`lib/x86_64-linux-gnu`, the Debian and Ubuntu default under `/usr`).
+  The relative path is now computed at configure time.
+- `mlr_walk_forward_splits` did not write `*count_out` on its `MLR_EINVAL`
+  paths; it now writes 0.
+- The fuzz sweep never fitted a GARCH model: every element was non-finite
+  with probability 0.11 and the fit needs 100 finite returns, so the
+  success path had probability 9e-6 per round. Every fourth round is now
+  clean, split parameters can hit every status code, and the sweep asserts
+  that the success paths were reached.
+- The C11 language requirement was exported to consumers through
+  `target_compile_features(PUBLIC)`; the public headers need only C99, so
+  it is now private. MSVC builds add `/fp:contract-`, the real counterpart
+  of `-ffp-contract=off`. The 32-bit CI leg uses SSE math instead of x87.
+- Documentation that no longer matched the code: `linreg.h` described the
+  pre-3.2.0 normal-equation solver; `sizing.h`'s lag-before-sizing warning
+  omitted the rolling statistics, which are contemporaneous; "with
+  ridge > 0 the system is always solvable" was overstated; `mlr_linreg_fit`
+  called its in/out model `model_out`.
+
+### Added
+
+- `mlr_version()` and `mlr_version_number()`, so a binding that loads the
+  compiled library can check what it loaded (the reference suite now does).
+- `MLR_GARCH_MIN_N` and `MLR_GARCH_MAX_PERSISTENCE` as public constants.
+- Header contracts a binding author asked for: partially written output on
+  `MLR_EDOMAIN`, count-query mode keyed on the pointer, the `backcast == 0`
+  sentinel, `converged` exactly 0 or 1, the model owning `w` and not being
+  copyable, `mlr_ewma_vol` all-NaN when no usable return precedes the last
+  index, the lag warning on each range estimator. README Conventions now
+  tabulates the five non-finite-element policies and states the `n == 0`
+  and trusted-`size_t` rules.
+- `MLRISK_BUILD_BENCH` option (default off); the benchmark is no longer
+  built with the examples.
+- A reference check that the purge rule is exactly the leakage boundary:
+  with labels spanning h periods, purge = h-1 leaves no training label
+  inside the test window and purge = h-2 does, for h = 2, 5 and 21.
+- The README says to demean with the training-window mean before fitting
+  (the full-sample mean is a lookahead) and quantifies the drift bias.
+
+### Changed
+
+- Size-overflow rejections in `mlr_lin_model_init` and `mlr_linreg_fit`
+  return `MLR_EINVAL` (a dimension that cannot be sized is bad input);
+  `MLR_ENOMEM` is reserved for a real allocation failure.
+- `tests/reference/requirements.txt` pins `statsmodels`; the reference
+  build uses `-O3` to match the CMake Release build.
+- Work arrays in `mlr_linreg_fit` are zero-initialized; GCC's analyzer
+  flagged reads it could not prove written (they were), and removing the
+  question costs nothing next to the solve.
+
+
+## 3.2.0 (2026-09-04)
+
+A second review (by a reader who had not seen the code before) named six
+weak spots. Four were real bugs or traps and are fixed; the other two were
+design choices and are now either better or better documented.
+
+### Fixed
+
+- `mlr_linreg_fit` sized its work arrays with a constant chosen for 64-bit
+  `size_t`; on 32-bit targets the `d * (d + 1)` product wrapped for d above
+  about 23,000 and the fit could write past its allocation. Sizes are now
+  checked arithmetically before anything is allocated or read.
+- `mlr_vol_target_position` accepted an `equity` and `max_leverage` whose
+  product overflowed, which made the cap infinite and therefore never
+  applied. Such a pair is now `MLR_EINVAL`.
+- Passing the same array as input and output corrupted rolling and EWMA
+  results. Output parameters are now `restrict`-qualified (`MLR_RESTRICT`,
+  empty under C++) and the contract is documented in `types.h`.
+- Continuing a fitted GARCH model onto new data by filtering the new data
+  alone restarted the recursion from the pre-sample backcast (about 30% off
+  at the first period on the test series). `mlr_garch_filter_from` starts
+  from a given variance, and with `model->sigma2_next` reproduces the tail
+  of the full filter bit for bit; the example uses it and the plain filter's
+  header explains the trap.
+
+### Changed
+
+- The regression solver is Householder QR on the centered design with
+  `sqrt(ridge) I` appended, instead of Gaussian elimination on the normal
+  equations. Accuracy is now about condition number times epsilon (2.8e-8
+  at condition number 1e8, where the old solver refused the problem and was
+  already at 1.5e-5 by 1e6). Same API, same results on well-conditioned data
+  to 1e-14.
+- `mlr_kelly_fraction` is documented as a sizing utility and an upper bound,
+  not an allocation model.
+
+### Added
+
+- Reference checks for the QR solver on designs with condition numbers
+  1e4 to 1e10 against SVD least squares, and for `mlr_garch_filter_from`
+  continuation; C tests for the ill-conditioned fit, the cap overflow, the
+  continuation, and the 32-bit size guard.
+
+
+## 3.1.0 (2026-09-03)
+
+Verification release. Every public function is now compared against an
+independent implementation on every push, and the pass turned up a handful
+of contract gaps.
+
+### Fixed
+
+- The GARCH optimizer's convergence test measured the simplex relative to
+  each parameter's own magnitude, so a maximum on the boundary `alpha = 0`
+  (returns with no ARCH effect) could never satisfy it: the fit ran to the
+  2000-iteration cap, took 16x longer than it should, and reported
+  `converged = 0` on a finished fit. The simplex is now measured against a
+  fixed scale per parameter (the backcast for omega, 1 for alpha and beta).
+- `mlr_garch_fit` ran Nelder-Mead once, from the best grid point, and could
+  stop in the wrong basin: against a 108-start brute-force search on the
+  identical likelihood it lost on three of eleven adversarial series (tiny
+  alpha with a second maximum at persistence 0.99, a 50-sigma outlier, a
+  fourfold variance regime switch), by up to 1.7 log-likelihood units. It now
+  runs from its three best grid points, restarts each from its own result
+  until that stops improving, and keeps the best; it matches the brute-force
+  optimum on ten of the eleven and beats it on the outlier series. Fits cost 5 to 7x what they did (8 ms at n = 1000).
+- `mlr_vol_target_position` let a denormal price overflow `equity / price`
+  past the leverage cap (an infinite position with `MLR_OK`), and let a
+  denormal position slip the cap by rounding; both are now zero.
+- `mlr_garch_filter` and `mlr_garch_forecast` emitted `Inf` when extreme but
+  valid parameters overflowed the recursion; they now return `MLR_EDOMAIN`.
+- `mlr_lin_model_init` and `mlr_linreg_fit` refuse dimensions whose
+  allocation size would overflow (`MLR_ENOMEM`) instead of relying on
+  `calloc` to notice.
+- `mlr_garch_filter` treated a finite return whose square overflows as data,
+  pinning every later sigma at `Inf` with `MLR_OK`; it is now treated as
+  missing, the same rule EWMA already used.
+- `mlr_garman_klass_vol` accepted bars with the open or close outside
+  `[low, high]`. They now give `NAN`. On a consistent bar the estimator is
+  bounded below by `0.114 * ln(high/low)^2`, so the "negative variance"
+  branch was unreachable and has been removed from the code and the docs.
+- The installed `mlrisk.pc` hard-coded the configure-time prefix, so an
+  install with `--prefix` produced a pkg-config file pointing at the wrong
+  tree. It is now relocatable (`${pcfiledir}/../..`).
+- `$<INSTALL_INTERFACE>` hard-coded `include` instead of
+  `CMAKE_INSTALL_INCLUDEDIR`; install and export rules are now behind
+  `MLRISK_INSTALL` so a parent project does not inherit them.
+- A GCC `-Wmaybe-uninitialized` in the GARCH grid search would have failed
+  the `-Werror` build on the Linux/gcc CI leg.
+- `mlr_drawdown_scale` returned `MLR_EDOMAIN` for a non-finite equity value
+  while every other function returns `MLR_EINVAL` for non-finite input; it
+  now returns `MLR_EINVAL` (non-positive equity is still `MLR_EDOMAIN`).
+- Header and README claims corrected: the PnL of a position is
+  `position[t] * price[t-1] * returns[t]` (the price factor was missing);
+  the GARCH constraint is `alpha + beta < 0.9999`; only alpha and beta are
+  scale invariant; `n <= d` with `ridge == 0` returns `MLR_EDOMAIN` rather
+  than fitting exactly; rolling std is O(n) on clean data with an O(window)
+  rebuild after each gap.
+
+### Added
+
+- `tests/reference/reference_check.py`: 19 checks of the compiled C against
+  pandas, numpy, scikit-learn, `arch`, exact rational arithmetic, an
+  independent split generator, a bitwise no-lookahead sweep, a 400-fit
+  GARCH Monte Carlo, and a reconciliation of the example's printed PnL.
+  A `reference` CI job runs it on every push.
+- Prefix-stability tests for EWMA and the rolling statistics (previously
+  only the GARCH filter had one), tests for `window == n`, all-NaN rolling
+  input, NULL outputs on the range estimators, and the GARCH filter
+  overflow rule.
+- `tests/test_fuzz.c`: 4000 randomized calls across the whole API (NaN, Inf,
+  denormals, `SIZE_MAX` arguments) asserting the documented contracts; runs
+  under the sanitizers in CI and found the two sizing/filter holes above.
+- `tests/reference/real_data_check.py` for daily OHLC files, and
+  `bench/bench.c` (`mlrisk_bench`) with per-element timings and scaling ratios.
+- A 32-bit (`-m32`) CI leg, so the `size_t` guards are exercised where
+  `size_t` is 32 bits; the workflow now runs on every branch push and can be
+  dispatched by hand.
+- The sanitizer CI job also runs the example; the Windows example step
+  declares its shell; the workflow passes `actionlint`.
+- The C two-pass reference in the rolling tests is computed on shifted
+  values so that it is itself exact at large levels.
+
+
+## 3.0.0 (2026-09-03)
+
+Breaking release. Every volatility forecast now shares one timing convention,
+and a technical audit closed a set of silent-failure paths.
+
+### Breaking
+
+- `mlr_ewma_vol` is predictive: `out[t]` is the forecast for period t from
+  `returns[0..t-1]`, matching `mlr_garch_filter`. Previously `out[t]` included
+  `returns[t]`, so sizing period t from it was a one-bar lookahead. `out[0]` is
+  now `NAN`. `lambda` must be in `[0, 1)`.
+- `mlr_lin_model_init(model, d)` drops the ridge argument; the `ridge` field is
+  written by `mlr_linreg_fit` with the value actually used (it was previously
+  never updated and could disagree with the fit).
+- `mlr_garch_fit` requires `n >= 100` (was 20).
+- `mlr_garch` gained a `backcast` field (appended). The recursion starts from
+  `sigma2[0] = omega + (alpha + beta) * backcast`, the `arch` presample rule.
+  Fitted parameters move by about 1e-5 relative to 2.0.0.
+- CMake 3.21 is required; the library compiles as strict ISO C11.
+
+### Fixed
+
+- `mlr_garch_filter` seeded its recursion from the series being filtered, so
+  every output depended on future returns. The seed now comes from the model.
+- `mlr_garch_fit` had an absolute feasibility floor on `omega`; returns with
+  rms below about 2e-8 returned an unfitted model with `MLR_OK`. The bound is
+  now positivity only and estimates are scale invariant.
+- Nelder-Mead stopped on function-value spread alone, so parameter accuracy
+  varied about 1000x with the units of the returns. Convergence now also
+  requires a small simplex; accuracy is about 1e-7 at any scale.
+- `mlr_garch_filter` and `mlr_garch_forecast` accepted `omega = Inf` from
+  hand-built models and produced `Inf`/`NaN` output with `MLR_OK`.
+- `mlr_walk_forward_splits` could wrap `size_t` arithmetic: a huge `embargo`
+  placed the post-test training segment inside the test window, and a huge
+  `train_len` produced out-of-range splits, both with `MLR_OK`.
+- `mlr_linreg_fit` accepted NaN or Inf inputs (NaN pivots passed the
+  singularity test) and negative ridge, producing garbage models with
+  `MLR_OK`. Its singularity threshold had an absolute floor that rejected
+  well-conditioned systems with features below about 1e-8.
+- `mlr_linreg_predict` dereferenced a freed model.
+- `mlr_vol_target_position` did not check `equity` or `max_leverage` for
+  finiteness: NaN equity gave NaN positions, Inf leverage disabled the cap.
+- `mlr_kelly_fraction` could return NaN with `MLR_OK` on overflowing sums.
+- Missing data no longer poisons `mlr_ewma_vol` or `mlr_garch_filter`; the
+  forecast already made is kept and the recursion carries on.
+- Range estimators return `NAN` rather than `Inf` when the price ratio overflows.
+
+### Added
+
+- `mlr_garch_fit` is checked against the Python `arch` package on identical
+  samples with an identical likelihood (`tests/reference/garch_arch_reference.py`).
+- Tests for prefix stability of the GARCH filter, scale invariance of the fit,
+  the timing alignment of every forecast, ridge shrinkage, and all of the
+  input-validation paths above. Tests run per module under ctest.
+- `mlrisk/version.h` (`MLRISK_VERSION`), a pkg-config file, and CMake options
+  `MLRISK_WERROR`, `MLRISK_BUILD_TESTS`, `MLRISK_BUILD_EXAMPLES` for consumers.
+- The example runs a walk-forward GARCH fit, filter, and sizing loop and
+  reports realized strategy volatility against the target.
+
+## 2.0.0
+
+Public API rework: `mlr_` prefix on every function, purged and embargoed
+walk-forward splits with a capacity-safe API, GARCH(1,1), range estimators,
+Kelly and drawdown sizing. No compatibility layer with 1.x.

walkforward-3.4.0/CMakeLists.txt

@@ -0,0 +1,112 @@
+cmake_minimum_required(VERSION 3.21)
+project(mlrisk VERSION 3.4.0 LANGUAGES C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
+
+option(MLRISK_WERROR "Treat warnings as errors" ${PROJECT_IS_TOP_LEVEL})
+option(MLRISK_BUILD_TESTS "Build the test suite" ${PROJECT_IS_TOP_LEVEL})
+option(MLRISK_BUILD_EXAMPLES "Build the examples" ${PROJECT_IS_TOP_LEVEL})
+option(MLRISK_BUILD_BENCH "Build the benchmark" OFF)
+option(MLRISK_INSTALL "Generate install and export rules" ${PROJECT_IS_TOP_LEVEL})
+
+include(GNUInstallDirs)
+
+if(MSVC)
+    # /fp:contract- forbids fused multiply-add the way -ffp-contract=off does
+    set(MLRISK_COMPILE_OPTIONS /W4 /fp:precise /fp:contract- $<$<BOOL:${MLRISK_WERROR}>:/WX>)
+else()
+    # -ffp-contract=off: no fused multiply-add, so results match across
+    # compilers and architectures to the last bit
+    set(MLRISK_COMPILE_OPTIONS -Wall -Wextra -Wpedantic -ffp-contract=off
+        $<$<BOOL:${MLRISK_WERROR}>:-Werror>)
+endif()
+
+configure_file(include/mlrisk/version.h.in include/mlrisk/version.h @ONLY)
+
+add_library(mlrisk STATIC
+    src/rolling.c
+    src/sizing.c
+    src/vol.c
+    src/split.c
+    src/linreg.c
+    src/version.c
+)
+add_library(mlrisk::mlrisk ALIAS mlrisk)
+
+# Built as C11; the public headers need only C99, so no standard is exported
+target_compile_features(mlrisk PRIVATE c_std_11)
+target_compile_options(mlrisk PRIVATE ${MLRISK_COMPILE_OPTIONS})
+target_include_directories(mlrisk PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+if(UNIX)
+    target_link_libraries(mlrisk PUBLIC m)
+endif()
+
+if(MLRISK_BUILD_TESTS)
+    enable_testing()
+    add_executable(mlrisk_tests
+        tests/test_main.c
+        tests/test_rolling.c
+        tests/test_sizing.c
+        tests/test_vol.c
+        tests/test_split.c
+        tests/test_linreg.c
+        tests/test_fuzz.c
+    )
+    target_compile_options(mlrisk_tests PRIVATE ${MLRISK_COMPILE_OPTIONS})
+    target_link_libraries(mlrisk_tests PRIVATE mlrisk::mlrisk)
+    foreach(module rolling vol sizing split linreg fuzz)
+        add_test(NAME ${module} COMMAND mlrisk_tests ${module})
+    endforeach()
+endif()
+
+if(MLRISK_BUILD_EXAMPLES)
+    add_executable(vol_target_demo examples/vol_target_demo.c)
+    target_compile_options(vol_target_demo PRIVATE ${MLRISK_COMPILE_OPTIONS})
+    target_link_libraries(vol_target_demo PRIVATE mlrisk::mlrisk)
+
+endif()
+
+if(MLRISK_BUILD_BENCH)
+    add_executable(mlrisk_bench bench/bench.c)
+    target_compile_options(mlrisk_bench PRIVATE ${MLRISK_COMPILE_OPTIONS})
+    target_link_libraries(mlrisk_bench PRIVATE mlrisk::mlrisk)
+endif()
+
+if(MLRISK_INSTALL)
+include(CMakePackageConfigHelpers)
+
+install(TARGETS mlrisk EXPORT mlriskTargets
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        FILES_MATCHING PATTERN "*.h")
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/mlrisk/version.h
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mlrisk)
+install(EXPORT mlriskTargets NAMESPACE mlrisk::
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/mlrisk)
+
+configure_package_config_file(cmake/mlriskConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/mlriskConfig.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/mlrisk)
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/mlriskConfigVersion.cmake
+    COMPATIBILITY SameMajorVersion)
+install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/mlriskConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/mlriskConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/mlrisk)
+
+# The .pc file locates the prefix relative to its own directory, whatever
+# the depth of CMAKE_INSTALL_LIBDIR (lib, lib64, lib/x86_64-linux-gnu, ...)
+file(RELATIVE_PATH MLRISK_PC_TO_PREFIX
+     "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig" "${CMAKE_INSTALL_PREFIX}")
+string(REGEX REPLACE "/$" "" MLRISK_PC_TO_PREFIX "${MLRISK_PC_TO_PREFIX}")
+configure_file(cmake/mlrisk.pc.in ${CMAKE_CURRENT_BINARY_DIR}/mlrisk.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/mlrisk.pc
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+endif()

walkforward-3.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 mlrisk contributors
+
+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.

walkforward-3.4.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.1
+Name: walkforward
+Version: 3.4.0
+Summary: Volatility forecasts, position sizing and purged walk-forward splits that never see the future
+Keywords: walk-forward,purged-cross-validation,backtesting,lookahead-bias,volatility,garch,position-sizing,quantitative-finance
+Author: Haegan McGarry
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Project-URL: Homepage, https://github.com/haeganm/walkforward
+Project-URL: Changelog, https://github.com/haeganm/walkforward/blob/main/CHANGELOG.md
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.23
+Provides-Extra: sklearn
+Requires-Dist: scikit-learn>=1.1; extra == "sklearn"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: scikit-learn>=1.1; extra == "test"
+Requires-Dist: pandas>=1.5; extra == "test"
+Description-Content-Type: text/markdown
+
+# walkforward
+
+> Volatility forecasts, position sizing and purged walk-forward splits that never see the future. A C11 library with a numpy front door.
+
+```bash
+pip install walkforward
+```
+
+Most backtests that look good are quietly peeking one bar ahead. The estimator that sizes a position knows the return it is about to earn, or a training label was computed from prices inside the test window. This library is built so those two things cannot happen by accident, and it is checked on every push against pandas, numpy, scikit-learn, the `arch` package and exact rational arithmetic.
+
+- **One timing convention.** Every forecast at index `t` is built from data before `t`. `ewma_vol` and the GARCH filters are predictive; the rolling statistics and range estimators are contemporaneous and say so in their own docstrings, with `lag` to fix them.
+- **Purging that asks the right question.** `PurgedWalkForward` takes a label horizon, not a purge count, because `purge = h - 1` is the part people get wrong. Drops straight into `cross_val_score`.
+- **GARCH(1,1) by maximum likelihood**, checked against `arch` on identical samples and identical likelihoods, and invariant to the units of the returns.
+- **Sizing that fails closed.** A bad price gives a zero position, not a NaN one. A leverage cap that could overflow is refused rather than silently ignored.
+- **Ridge by Householder QR**, so a feature at a price level near 1e9 keeps its slope precision.
+
+Research tooling, not investment advice. It is a set of building blocks, not a backtester: it knows nothing about costs, borrow, calendars or corporate actions.
+
+## The loop
+
+```python
+import numpy as np
+import walkforward as wf
+
+# The fit assumes mean-zero returns. Demean with the TRAINING mean; the
+# full-sample mean would put the future into the fit.
+train = returns[:1000] - returns[:1000].mean()
+model = wf.garch_fit(train)
+
+# sigma[t] forecasts period t from returns before t. filter_from continues
+# from the variance state the fit ended on, which is what makes the
+# out-of-sample path the same as filtering everything together.
+sigma = model.filter_from(returns[1000:])
+
+# A position held over period t is entered at the close of t-1, so it is
+# sized against the previous close, and earns position * price * return.
+entry = close[999:-1]
+position = wf.vol_target_position(
+    sigma, target_vol=0.01, equity=100_000.0, price=entry, max_leverage=2.0
+)
+pnl = position * entry * returns[1000:]
+```
+
+`model.persistence`, `model.half_life` and `model.unconditional_vol` are there so you do not have to recompute them.
+
+## Cross-validation
+
+```python
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.model_selection import cross_val_score
+import walkforward as wf
+
+# Target is a 21-period forward return, so labels span 21 periods and the
+# last 20 training rows before each test window are dropped.
+cv = wf.PurgedWalkForward(train_size=756, test_size=252, label_horizon=21)
+
+scores = cross_val_score(GradientBoostingRegressor(), X, y, cv=cv)
+```
+
+Without the purge, the twenty training rows before each test window carry labels that were partly computed from test-window prices. The library counts that leak in its own test suite: at a horizon of 21, a purge of 20 leaves zero leaking training rows and a purge of 19 leaves ten.
+
+There is no `embargo` argument, on purpose. An embargo protects training data that sits after a test window, and a walk-forward never trains on anything after the window it is testing. `walk_forward_splits(..., include_post_train=True)` exposes that variant with the warning it deserves.
+
+## Conventions
+
+Volatility is per period. Annualised converts as `annual / sqrt(periods_per_year)`, so a 10% annual target on daily data is `0.10 / sqrt(252)`, about 0.0063.
+
+`rolling_std` uses the population convention and divides by `window`. Pandas `rolling().std()` defaults to the sample convention, so the two differ by `sqrt(window / (window - 1))`.
+
+A pandas Series in gives a pandas Series out, on the same index. Realigning a bare array by hand is one of the ways lookahead gets in.
+
+Bad arguments raise. Bad elements are handled per function and documented on each: a non-finite return is skipped by the recursions, makes a rolling window NaN, and gives a zero position in sizing. `DomainError` (a `ValueError`) means the arguments were fine but the computation has no answer: a singular design, a sample with no variance, an overflowing recursion.
+
+## What it is checked against
+
+The C library underneath is compared on every push to independent implementations, and the numbers are reproducible from `tests/reference/` in the repository.
+
+| Check | Reference | Result |
+|---|---|---|
+| Rolling mean and std, with gaps | pandas | 3.1e-11 |
+| Rolling std at a price level of 1e9 | exact rational arithmetic | 1.7e-15, where a two-pass computation is off by 4.9e-12 |
+| EWMA, predictive alignment | pandas `ewm` shifted one period | 3.5e-18 |
+| GARCH filter and forecast | `arch` | 4.4e-16 relative |
+| GARCH fit over 20 samples | `arch`, same likelihood | 5.0e-7 max parameter difference |
+| Ridge, condition number 1e4 to 1e10 | SVD least squares | within 2x condition times epsilon |
+| Ridge with a feature at level 1e6 to 1e15 | exact rational OLS | under 1e-14 |
+| Walk-forward splits, 1620 parameter sets | independent generator | 0 mismatches |
+| No lookahead, 40 trials | bitwise prefix comparison | 0 violations |
+
+The C also runs under AddressSanitizer and UndefinedBehaviorSanitizer, on 32-bit and 64-bit, and gives bit-identical answers under GCC and Clang.
+
+## License
+
+MIT. Source and the C library: https://github.com/haeganm/walkforward