hanalyze

🌐 English | 日本語

hanalyze is a Haskell-native statistical engineering toolkit: regression, GLMM, Bayesian inference (HMC/NUTS/Gibbs/ADVI/SMC), Gaussian processes, machine learning (SVM / gradient boosting / neural networks), survival analysis (KM / Cox / AFT / competing risks), time series (ARIMA / GARCH / state space), causal discovery (LiNGAM) and treatment-effect estimation, design of experiments (classical + custom optimal design), multi-objective optimisation, native plotting, and HTML reporting integrated under one API. Core modelling and optimisation logic is implemented in Haskell, with numerical linear algebra delegated to hmatrix/BLAS/LAPACK. No R/Stan/Python bridge required. Benchmarks (see below) show competitive accuracy with Python/R references in the tested cases. Performance varies by domain: optimisation and small-to-medium MCMC workloads are often faster in these benchmarks, while large-scale ML/GLM workloads are currently slower than sklearn.

Highlights

• Haskell-native: types catch many dtype/API mismatches; shape checks happen at runtime where needed
• Algorithms in Haskell, BLAS for numerics: hmatrix/BLAS/LAPACK powers linear algebra; no R/Stan/Python bridge
• Native plotting: 90+ documented figure types through the hgg grammar-of-graphics integration (separate hanalyze-plot package, build with cabal build --project-file=cabal.project.plot) — pure-Haskell SVG output, no browser required (see Gallery)
• HTML reporting: MathJax/Mermaid + Vega-Lite visualisations in one call; PNG/SVG export available for supported plots
• Dirty-data defence: 8 warning codes + auto-sniff (delim/header/encoding) + cleaning DSL
• Hackage dataframe: Polars-like DataFrame used directly; CSV native, Parquet/JSON support through dataframe

Gallery

Every figure below (and 90+ more across docs/) is generated straight from analysis results via the hgg integration — pure Haskell, SVG out.

Linear regression — fit + 95% CI (docs)	Bayesian MCMC dashboard — trace / density / R̂ / ESS (docs)
Gaussian process — mean + credible band (docs)	Kernel SVM (RBF) — decision boundary + support vectors (docs)
DOE prediction profiler — response vs each factor + CI (docs)	RSM response surface (3D) (docs)
DirectLiNGAM causal discovery — estimated DAG (docs)	Kaplan-Meier survival curves (docs)
Time-series forecast (docs)	k-means clusters + 95% ellipses (docs)

Capabilities

Features are organised by topic, with the details delegated to the per-topic docs and the package READMEs. The full index is docs/README.md; the exhaustive API dictionary is docs/api-guide/ (12 chapters).

One entry point: every model is fitted with df |-> spec and drawn with toPlot. The plotting integration lives in a separate package, hanalyze-plot (cabal build --project-file=cabal.project.plot).

Version compatibility with the plotting ecosystem:

Installation

Requirements

Using it as a library

This repository is a 10-package multi-package project and is not published as a package yet. Clone it and list the packages in your own cabal.project.

git clone https://github.com/frenzieddoll/hanalyze

-- cabal.project
packages: .
          ./hanalyze/hanalyze
          ./hanalyze/hanalyze-core
          ./hanalyze/hanalyze-frame
          ./hanalyze/hanalyze-bayes
          ./hanalyze/hanalyze-models
          ./hanalyze/hanalyze-design
          ./hanalyze/hanalyze-viz

For build-depends, hanalyze alone is the default answer (module names do not change across layers). Name a layer directly only when you want to narrow the dependency. Each package has a README with a module map and a standalone example.

Opt-in build roots

The default cabal.project is plot-independent; switch roots as needed.

Just the CLI

cabal install hanalyze-cli    # installs the hanalyze command

Quick start

30 seconds via CLI

git clone https://github.com/frenzieddoll/hanalyze
cd hanalyze

# Regress sales on price + promo, write an HTML report.
cabal run hanalyze -- regress data/readme/sales.csv "price promo" sales --report sales.html
# β₀=185.05  β(price)=-4.37  β(promo)=+32.29  R²=0.995

data/readme/sales.csv is a 20-row demo CSV shipped with the repository (price, promo, sales). The generated sales.html includes coefficients, fit diagnostics, and an interactive prediction widget — straight from one command.

30 seconds via Haskell API

import qualified Hanalyze.Stat.Test as ST
import qualified Numeric.LinearAlgebra as LA

main = do
  let xs = LA.fromList [12, 14, 13, 15, 17, 11]
      ys = LA.fromList [18, 22, 20, 19, 25, 17]
      result = ST.tTestWelch xs ys ST.TwoSided
  print (ST.trPValue result, ST.trEffect result)
  -- (1.688e-3, Just ("Cohen's d", -2.527))

A single import Hanalyze re-exports the core entry points (linear / GLM models, descriptive stats, tests, effect sizes, distributions, plotting helpers and CSV I/O) for quick exploration; reach for the individual Hanalyze.Model.* / Hanalyze.Stat.* modules when you need their full surface.

See docs/01-quickstart.md for a fuller introduction.

CLI

hanalyze help                     list subcommands
hanalyze regress <file> <x> <y>   LM/GLM/GP/HBM regression + HTML report
hanalyze info <file>              per-column type/statistics
hanalyze hist <file> <col>        histogram with theoretical PDF overlay
hanalyze ridge <file> ...         regularised regression (Ridge/Lasso/EN)
hanalyze kernel <file> ...        kernel regression (NW/KR/RFF), multi-D inputs
hanalyze spline <file> ...        spline regression
hanalyze multireg <file> ...      multi-output regression + interactive HTML
hanalyze melt <file> ...          long-form transform
hanalyze regrid <file> ...        time-axis grid alignment
hanalyze doe ortho <NAME> -f ...  orthogonal-array generation
hanalyze taguchi sn / analyze     Taguchi method
hanalyze clean <file> --rule ...  dirty-data cleaning

For per-command flags, run hanalyze <cmd> --help or see docs/01-quickstart.md.

Examples / demos

hanalyze-demos/demo/ contains many demos (76 as of this release). Highlights:

Run: dist-newstyle/build/x86_64-linux/ghc-9.6.7/hanalyze-demos-0.2.0.1/x/<demo-name>/build/<demo-name>/<demo-name>.

Where hanalyze fits

Rather than a complete Python/R replacement, hanalyze targets specific workflows where Haskell integration, single-binary CLI, and tight reporting add value.

Strong fit

• Haskell-native pipelines that need stats/Bayes/optim without calling out to Python
• Single-binary CLI distribution (one hanalyze binary, no Python venv)
• Dirty-CSV defence + cleaning + analysis in one workflow
• DoE / Taguchi / orthogonal arrays for manufacturing and process tuning
• HTML reports straight from the analysis (no separate templating step)
• Type-safe analysis pipelines that catch dtype/API mismatches early

Not a goal — keep using existing tools for

• Large-scale DataFrame work (pandas / polars / data.table)
• GPU deep learning (PyTorch / JAX)
• The full breadth of scikit-learn's mature model zoo
• The full Stan / PyMC MCMC diagnostics ecosystem
• The full expressive range of ggplot2

Comparison vs Python

R is included in the feature map only — no numerical bench against R has been run.

Numbers below come from bench/results/{haskell,python}/*.csv; see bench/results/SUMMARY.md for the full table and benchmark conditions (OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1, single-thread, deterministic seeds).

See docs/comparison/python-r.md for the feature map, and bench/results/SUMMARY.md for numbers.

Benchmark highlights

Selected results from bench/results/SUMMARY.md. Each entry is a single benchmark configuration; absolute objective values depend on iteration counts, seeds, and tolerances — see the SUMMARY for full conditions. NUTS is additionally validated against posteriordb reference posteriors (see bench/posteriordb/).

• NUTS 8-schools (warmup 500, samples 1000): hanalyze 1492 ms with ESS(mu) 839 vs blackjax 530 ms / ESS 810 in this run
• Holt-Winters seasonal n=500 p=12: hanalyze 0.19 ms vs statsmodels MLE 96 ms in this run (note: hanalyze uses fixed α=0.3 closed-form; statsmodels does MLE)
• Sphere_30D/DE: hanalyze 1.0e-26 vs scipy 2.8e-5 on this benchmark
• Sphere_30D/L-BFGS: hanalyze 8.1e-40 vs scipy 2.6e-11 on this benchmark
• Rastrigin_10D/SA: hanalyze 0.0 vs scipy dual_annealing 7.8e-14 in this run
• Hartmann6/BO: hanalyze -3.07 vs skopt -2.77 in this run
• DTLZ2_3/NSGA-II: hanalyze 528 ms vs pymoo 758 ms (1.43× faster in this run)
• DE Rosenbrock_2D: hanalyze 1.2 ms vs scipy 164 ms (134× faster in this run)
• Constrained Quad2D (eq): hanalyze 0.062 ms vs scipy SLSQP 0.69 ms in this run
• regridLong on jagged long-form: hanalyze 0.99 ms vs pandas+scipy synthesis 19.4 ms in this run

Reproduce: OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 cabal run bench-{regression,kernel,optim,mo,bo,mcmc-b7,mcmc-extras,ts-extras,optim-plus,stat-util,multi-output,regrid}, then bench/python/bench_*.py (see bench/README.md).

Architecture

graph TD
  IO[DataIO.* CSV/Parquet/JSON]
  IO --> DF[Hackage dataframe]
  DF --> Models[Model.* regression/ML/Bayesian/TS/Survival]
  DF --> Stat[Stat.* tests/CV/effect/interpret]
  Models --> Optim[Optim.* optimisation]
  Models --> MCMC[MCMC.* samplers]
  Models --> Viz[Viz.* HTML/PNG/SVG]
  Stat --> Viz
  MCMC --> Viz
  Optim --> Design[Design.* DoE/Taguchi]

All modules talk to Hackage dataframe directly. The internal DataFrame.Core was retired.

Roadmap & API stability

• Stable (API expected to remain backward-compatible within minor versions): Hanalyze.DataIO.*, Hanalyze.Stat.{Test, Bootstrap, MultipleTesting, ClassMetrics, CV, Effect, Distribution}, Hanalyze.Model.{LM, GLM, Spline, Regularized, RandomForest, DecisionTree, TimeSeries, Survival, GAM}, Hanalyze.Optim.{NelderMead, LBFGS, DifferentialEvolution, CMAES, NSGA, BayesOpt, SimulatedAnnealing, ParticleSwarm}, Hanalyze.Design.*, Hanalyze.Viz.{Scatter, Bar, Histogram}.
• Experimental (API may evolve): Hanalyze.Model.HBM DSL, Hanalyze.MCMC.NUTS (mass-matrix adaptation is opt-in), Hanalyze.Stat.VI (ADVI), Hanalyze.Model.{GP, RFF, GPRobust, GLMM}, Hanalyze.Model.{SVM, GradientBoosting, NeuralNetwork}, Hanalyze.Model.LiNGAM.*, Hanalyze.Design.Custom.*, the df |-> spec fit operator (Hanalyze.Fit), the hgg integration (cabal.project.plot build root), Hanalyze.Viz.ReportBuilder. Behaviour is benchmarked but type signatures may shift.
• Future direction: a backend-abstraction typeclass for swapping hmatrix/Massiv/Accelerate is under consideration but not on a fixed schedule. (The unified top-level re-export layer and the fit-operator API planned earlier landed in 0.2.0.0 as module Hanalyze and Hanalyze.Fit.)

Module layout

Multi-package since Phase 106 (2026-07-19). The umbrella package hanalyze re-exports every module under its original name, so downstream imports are unchanged. Packages sit flat at the repo root and the root itself is a pure workspace (cabal.project only, no root package) — the conventional layout for Haskell library monorepos (cabal, plutus).

hanalyze/         — umbrella: Fit/Wrappers/Diagnostics/Analyze + re-exports, test suite
hanalyze-core/    — Math kernels, low-level Stat, Optim, MCMC.Core, Model.Core (44 mods)
hanalyze-frame/   — Data/ + DataIO/ (CSV/JSON/Parquet IO, clean DSL, reshape) (14 mods)
hanalyze-bayes/   — HBM DSL/IR + MCMC samplers (MH/HMC/NUTS/Gibbs/Slice/SMC) + VI (26 mods)
hanalyze-models/  — LM/GLM/GLMM/GP/SVM/GBM/NN/Cluster/TS/Survival/LiNGAM/FDA etc. (67 mods)
hanalyze-design/  — Factorial/Block/RSM/Orthogonal/Taguchi + Custom optimal design (30 mods)
hanalyze-viz/     — Vega-Lite-based visualisation + ReportBuilder (19 mods)
hanalyze-plot/    — hgg integration (cabal.project.plot root only) (8 mods)
hanalyze-cli/     — the `hanalyze` CLI executable
hanalyze-demos/   — hanalyze-demos/demo/posteriordb executables (cabal.project.demos root only)

As of this release: 212 modules, ~1,390 test examples.

Build

cabal build all                  # umbrella library + CLI + test suite
cabal test all                   # hspec test suite
cabal repl hanalyze       # interactive REPL (umbrella)

Build roots: default cabal.project (standalone, no plot), cabal.project.plot (+ hgg integration), cabal.project.demos (+ hanalyze-demos/demo/posteriordb executables). See CONTRIBUTING for the full table.

Major dependencies: hmatrix (BLAS/LAPACK), hvega (Vega-Lite), statistics, mwc-random, dataframe (Hackage Polars-like), massiv (parallel arrays), ad (auto-diff), async.

Tested on GHC 9.6.7 + cabal 3.14.2.

Running benchmarks

# 1. Generate shared test data (fixed-seed, deterministic)
#    The benchmark executables live in the demos package, so pass that build root
cabal run --project-file=cabal.project.demos bench-data-gen

# 2. Haskell side
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 \
  cabal run --project-file=cabal.project.demos \\
    bench-regression bench-kernel bench-optim bench-mo bench-bo

# 3. Python side (need bench/venv from bench/requirements.txt)
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 \
  bench/venv/bin/python bench/python/bench_regression.py
# (similarly for kernel, optim, mo, bo)

# 4. Aggregate (Markdown table)
bench/venv/bin/python bench/aggregate.py > bench/results/SUMMARY.md

Development

• Issues / PRs: github.com/frenzieddoll/hanalyze
• Adding tests: append hspec specs in test/Spec.hs
• Adding benchmarks: place hanalyze-demos/bench/haskell/Bench*.hs and matching Python script
• Coding rules: see CONTRIBUTING.md (no list-passing on hot paths, minimise unsafe*, ...)

License

BSD-3-Clause License — see LICENSE.

Author

Toshiaki Honda frenzieddoll@gmail.com