jaxgsa 0.4.0__tar.gz

jaxgsa-0.4.0/.github/dependabot.yml

@@ -0,0 +1,21 @@
+version: 2
+updates:
+  # Keep the GitHub Actions used by CI / publish workflows up to date.
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns: ["*"]
+
+  # Keep the locked Python dependencies (uv.lock) current. Grouped into a
+  # single weekly PR to minimise noise; these are lockfile/dev pins, not the
+  # public version floors declared in pyproject.toml.
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      python-dependencies:
+        patterns: ["*"]

jaxgsa-0.4.0/.github/workflows/ci.yml

@@ -0,0 +1,42 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+
+      - name: Install project and dev dependencies
+        run: uv sync --extra dev
+
+      - name: Ruff format check
+        run: uv run ruff format --check .
+
+      - name: Ruff lint
+        run: uv run ruff check .
+
+      - name: Type check
+        run: uv run ty check src/jaxgsa
+
+      - name: Run tests
+        run: uv run pytest -q

jaxgsa-0.4.0/.github/workflows/docs-check.yml

@@ -0,0 +1,39 @@
+name: Check Docs
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/docs-check.yml"
+      - ".github/workflows/docs.yml"
+      - "README.md"
+      - "docs/**"
+      - "scripts/check_api_docs_coverage.py"
+      - "scripts/check_vitepress_pager.py"
+      - "src/jaxgsa/**"
+  push:
+    branches:
+      - master
+    paths:
+      - ".github/workflows/docs-check.yml"
+      - ".github/workflows/docs.yml"
+      - "README.md"
+      - "docs/**"
+      - "scripts/check_api_docs_coverage.py"
+      - "scripts/check_vitepress_pager.py"
+      - "src/jaxgsa/**"
+
+jobs:
+  docs-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+      - run: npm ci
+        working-directory: docs
+      - run: npm run docs:check
+        working-directory: docs

jaxgsa-0.4.0/.github/workflows/docs.yml

@@ -0,0 +1,47 @@
+name: Deploy VitePress to GitHub Pages
+
+on:
+  push:
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    if: contains(github.event.head_commit.message, '[build docs]') || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+      - run: npm ci
+        working-directory: docs
+      - run: npm run docs:check
+        working-directory: docs
+      - uses: actions/upload-pages-artifact@v5
+        with:
+          path: docs/.vitepress/dist
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v5

jaxgsa-0.4.0/.github/workflows/publish.yml

@@ -0,0 +1,48 @@
+# Publishes jaxgsa to PyPI when a GitHub Release is published.
+#
+# Setup required once on PyPI (no API tokens needed):
+#   PyPI project -> Settings -> Publishing -> add a "trusted publisher" for
+#   owner=DanielePessina, repo=jaxgsa, workflow=publish.yml, environment=pypi.
+# See https://docs.pypi.org/trusted-publishers/
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/jaxgsa
+    permissions:
+      id-token: write # OIDC token for PyPI trusted publishing
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

jaxgsa-0.4.0/.gitignore

@@ -0,0 +1,113 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# MacOS
+.DS_Store
+
+# Aim
+.aim/
+
+# VS Code config
+.vscode/settings.json
+
+# Repomix
+.repomix/
+*.xml
+
+# Claude Code
+.claude/
+
+# Local AI-agent instructions (kept on disk, not published)
+AGENTS.md
+CLAUDE.md
+
+# Temporary files
+tmp/
+
+
+.Rproj.user
+
+# GSA simulation results (keep metadata, ignore large output files)
+scripts/results/salib_runs/**/*_sim.xlsx
+scripts/results/salib_runs/**/*_sim.csv
+scripts/results/salib_runs/**/*_sim.feather
+# scripts/results/salib_runs/**/*_sim__*.parquet
+
+### Core LaTeX files
+*.aux
+*.lof
+*.log
+*.lot
+*.fls
+*.out
+*.toc
+*.fmt
+*.fot
+*.cb
+*.cb2
+.*.lb
+
+## Intermediate documents
+*.dvi
+*.xdv
+*-converted-to.*
+
+## Bibliography auxiliary files
+*.bbl
+*.bcf
+*.blg
+*-blx.aux
+*-blx.bib
+*.run.xml
+
+## Build tool auxiliary files
+*.fdb_latexmk
+*.synctex
+*.synctex(busy)
+*.synctex.gz
+*.synctex.gz(busy)
+*.pdfsync
+
+## Build tool directories
+latex.out/
+
+## Auxiliary and intermediate files from other packages
+*.makefile
+*.idx
+*.ilg
+*.ind
+
+## Glossaries
+*.acn
+*.acr
+*.glg
+*.glo
+*.gls
+*.glsdefs
+*.lzo
+*.lzs
+
+## Uncomment if you don't want to keep the PDF output
+# *.pdf
+
+## Backup files
+*.backup
+*.bak
+*~
+
+## Editor-specific files
+.vscode/
+.DS_Store
+*.swp
+*.swo
+*~
+
+docs/node_modules/

jaxgsa-0.4.0/.python-version

@@ -0,0 +1 @@
+3.12

jaxgsa-0.4.0/CHANGELOG.md

@@ -0,0 +1,304 @@
+# Changelog
+
+## 0.4.0
+
+### Changed
+
+- **BREAKING: renamed the package from `gsax` to `jaxgsa`.** The distribution
+  and import name are now `jaxgsa` (`pip install jaxgsa`, `import jaxgsa`). The
+  old `gsax` project on PyPI is frozen at `0.3.0b1` with no compatibility shim;
+  see the [0.3 → 0.4 migration guide](docs/guide/migration-0.4.md).
+- Replaced root-level command aliases with method namespaces such as
+  `jaxgsa.sobol.sample`, `jaxgsa.sobol.analyze`, `jaxgsa.pce.analyze`, and
+  `jaxgsa.hdmr.analyze`.
+- Moved surrogate prediction and Shapley derivation onto `PCEResult` and
+  `HDMRResult` through `predict(...)` and `shapley(...)`.
+- Enforced one output contract across methods: `(N,)`, `(N, K)`, or
+  `(N, T, K)`. Axis inference and automatic transposition were removed.
+- Renamed the main sampling/result types to `SobolSamples`, `SobolResult`, and
+  `MorrisSamples`.
+- Simplified Sobol persistence to one NPZ file through
+  `SobolSamples.save(...)` and `SobolSamples.load(...)`; removed pandas and
+  format-specific persistence dependencies.
+- Renamed the design row-count fields on `SobolSamples` and `MorrisSamples`:
+  `n_total` is now `n_runs` (unique rows you evaluate, one model run per row)
+  and `expanded_n_total` is now `n_expanded` (pre-deduplication design size).
+- Retyped the eFAST workflow: `jaxgsa.efast.sample(problem, n_per_curve, *, M=4,
+  ...)` (the second parameter was `N`) returns a typed `EFASTSamples` carrying
+  `samples`, `n_per_curve`, `M`, `problem`, and an `n_runs` property;
+  `jaxgsa.efast.analyze(samples, Y, ...)` is samples-first and no longer takes
+  `M` or `problem` — both are threaded from the design object, so a mismatch
+  between sampling and analysis is now impossible.
+- Tightened the eFAST design bound to `n_per_curve >= 4*M^2*(D-1) + 1` (was
+  `n_per_curve > 4*M^2`, independent of `D`). Below the new bound there are
+  not enough integer frequencies below `omega_0/(2M)` to give each non-focal
+  parameter a distinct one; the old code wrapped them cyclically, so two
+  parameters got the same frequency and the same phase and were therefore
+  identical along that search curve — a silent bias. Such designs now raise
+  `ValueError` from both `efast.sample` and `EFASTSamples`.
+- Standardized the batching vocabulary package-wide: `batch_size` always means
+  rows of X/Y per batch (`pce.analyze`, `hdmr.analyze`, `dgsm.analyze`,
+  `hsic.analyze`, and `result.predict`); output-slice chunking parameters were
+  renamed from `chunk_size` to `slice_chunk_size` on `hdmr`, `efast`, `sobol`,
+  `borgonovo`, `optimal_transport`, and `pawn` `analyze`.
+- Moved shared internals into a private `jaxgsa._core` package and introduced
+  private base classes for sample designs and surrogate results (internal
+  reorganization; no user-facing API change).
+
+### Added
+
+- Correlation-aware HDMR Shapley effects with
+  `result.shapley(include_correlative=True)`.
+- Dense structural `HDMRResult.S2` and `HDMRResult.S3` interaction arrays.
+- Bounded-memory batched prediction for PCE and HDMR result objects.
+- Automatic streaming fits for `jaxgsa.pce.analyze` and `jaxgsa.hdmr.analyze`:
+  when the estimated single-pass fit memory exceeds the active budget, the
+  fit streams over row batches. The streamed path is mathematically exact —
+  it accumulates the same Gram matrices and moments as the in-memory path
+  (PCE leave-one-out diagnostics stay exact via a second streamed pass),
+  differing only in floating-point summation order. An explicit `batch_size=`
+  forces streaming.
+- `jaxgsa.config.set_memory_budget(bytes)` / `jaxgsa.config.get_memory_budget()`:
+  an opt-in, process-global transient-memory budget (default 512 MiB) that
+  sizes every automatic batching decision — surrogate `predict` batches, HDMR
+  output-slice chunking, and the streaming fits. Explicit per-call
+  `batch_size` / `slice_chunk_size` parameters always take precedence.
+- `MorrisSamples.save(path)` and `MorrisSamples.load(path)`, using the same
+  single-NPZ format and metadata schema as `SobolSamples`.
+- `jaxgsa.shapley.analyze(problem, X, Y, backend="pce"|"hdmr", ...)`: a thin
+  convenience wrapper over the canonical result methods
+  (`pce.analyze(...).shapley()` / `hdmr.analyze(...).shapley(...)`).
+- A 0.3 to 0.4 API migration guide.
+
+### Improved
+
+- Power-of-2 validation errors now name the two nearest valid values, so the
+  message states exactly which sample counts would be accepted.
+
+## 0.3.0b1
+
+### Added
+
+- **Optimal-transport sensitivity indices**
+  (`jaxgsa.optimal_transport`, re-exported as `jaxgsa.analyze_optimal_transport()`):
+  the Wasserstein-based distributional indices of Borgonovo, Figalli,
+  Plischke & Savaré (2024, Management Science, doi:10.1287/mnsc.2023.01796) —
+  the class-averaged squared 2-Wasserstein distance between conditional and
+  unconditional output distributions, normalized to [0, 1] by `2 * Var(Y)`,
+  with
+  - an exact **advective/diffusive decomposition** of every index: the
+    advective (location-shift) component equals half the given-data
+    first-order Sobol index, the diffusive remainder captures changes in
+    spread, tails and shape;
+  - three output modes: `"univariate"` (default; per output column via the
+    closed-form 1-D sorted-quantile coupling — no iterative solver),
+    `"multivariate"` (one index per input over the flattened joint output as a
+    point cloud), and `"trajectory"` (one index per input per output
+    over each output's whole time course), covering scalar, multi-output,
+    and time-series `Y`;
+  - a pure-JAX **log-domain Sinkhorn** solver for the point-cloud modes (entropic
+    regularization on the max-scaled cost, unregularized `<P, C>` reported,
+    single post-hoc convergence warning), with per-output standardization
+    on by default;
+  - **rank-based conditioning**: distribution-free in X (uniform, Gaussian,
+    truncated-Gaussian, or mixed marginals work unchanged) and well-defined
+    for correlated inputs (total, correlation-inclusive influence);
+  - an opt-in `dummy=True` irrelevance baseline (a synthetic independent
+    input scored through the identical pipeline) to threshold against the
+    entropic/finite-sample index floor;
+  - percentile bootstrap confidence intervals sharing one scanned code path
+    with the point estimate, and `OTResult.to_dataset()` xarray export.
+  Implemented from the published equations; numerics are validated in
+  the test suite against POT (`ot.wasserstein_1d`,
+  `ot.sinkhorn2`, `ot.emd2`; new `pot` dev extra), analytic Gaussian closed
+  forms (new `jaxgsa.benchmarks.gaussian_linear.ANALYTICAL_OT` constant), the
+  published Ishigami anchor, and the `2 * advective == S1` identity.
+- Shared `jaxgsa._partition` module: the equal-frequency rank-partition
+  helpers (`_class_layout`, `_build_class_indices`) moved out of
+  `jaxgsa.borgonovo` so the Borgonovo delta and optimal-transport estimators
+  use one implementation (no behavior change).
+
+## 0.2.0
+
+### Added
+
+- **Morris** elementary-effects screening
+  (`jaxgsa.morris`, re-exported as `jaxgsa.morris.sample()` /
+  `jaxgsa.morris.analyze()`): globalized one-at-a-time screening that reduces
+  `r * (D + 1)` model evaluations to mu, mu_star (importance ranking), and
+  sigma (nonlinearity/interaction flag), with
+  - trajectory (Morris, 1991) and radial (Campolongo et al., 2011,
+    scrambled-Sobol' star) designs;
+  - uniform and Gaussian marginals — Gaussian coordinates are confined to a
+    truncated-quantile grid (`truncation_quantile`, default 0.005) so the
+    design probes the 0.5%–99.5% quantile range instead of unbounded tails;
+  - unique-row deduplication, so grid collisions across trajectories do not
+    cost real model evaluations (same contract as Saltelli `sample()`);
+  - scalar, multi-output, and time-series outputs, non-finite trajectory
+    cleaning, and bootstrap confidence intervals over trajectories;
+  - `MorrisSamples.downsample()` prefix-slicing to fewer trajectories
+    without re-simulation, and `MorrisResult.to_physical_units()` /
+    `to_dataset()` for derivative-scale measures and labeled xarray export.
+- **Shapley effects** (`jaxgsa.analyze_shapley`, `ShapleyResult`) — global
+  Shapley-value allocation of output variance across inputs (Owen 2014;
+  Song, Nelson & Staum 2016), computed analytically from a fitted surrogate's
+  variance decomposition instead of permutation Monte Carlo. Two backends:
+  `"pce"` (default; subset variances read off orthonormal polynomial
+  coefficients) and `"hdmr"` (RS-HDMR component-function variances); both
+  accept scalar, multi-output, and time-series outputs. Indices are
+  normalized by the surrogate's total decomposed variance, so `Sh` sums to
+  exactly 1 (the Shapley efficiency property); the `explained_variance` field
+  reports the fraction of `Var(Y)` the surrogate captured, and the `order`
+  field the effective surrogate order used. For the `"pce"` backend `S1`/`ST`
+  match `analyze_pce` exactly. A `UserWarning` flags a pathological fit
+  (`explained_variance` far from 1). Assumes independent inputs.
+- Closed-form analytical Shapley values (`ANALYTICAL_SHAPLEY`,
+  `analytical_shapley(...)`) for the Ishigami, linear, and Sobol-G
+  benchmarks, used to validate the new method.
+- `jaxgsa.borgonovo` subpackage — moment-independent, density-based sensitivity via
+  the Plischke, Borgonovo & Smith (2013) given-data estimator of Borgonovo's
+  (2007) delta index. `analyze` (top-level alias `analyze_borgonovo`) returns both
+  the delta index and the given-data first-order Sobol `S1` from the same
+  rank-class partition, with bootstrap bias correction (`2*d_hat - mean(d_boot)`)
+  and percentile confidence intervals. Works with any `(X, Y)` pairs and supports
+  scalar, multi-output, and time-series outputs.
+- `DeltaResult` dataclass holding the delta and `S1` indices with optional
+  bootstrap intervals and a `to_dataset()` xarray export.
+- `jaxgsa.benchmarks.gaussian_linear` — a Gaussian linear additive benchmark whose
+  Gaussian marginals give the Borgonovo delta index a semi-analytic solution
+  (`ANALYTICAL_DELTA`), for ground-truth validation of the delta estimator.
+- **Uniform output support across all ten methods** — every analyze entry point
+  now accepts `(N,)`, `(N, K)`, and `(N, T, K)` outputs. `analyze_pce`,
+  `analyze_shapley` (`"pce"` backend), and `dgsm.analyze` gained
+  multi-output/time-series support: PCE fits all output slices against one
+  shared basis in a single multi-right-hand-side solve, and DGSM accepts
+  `(T, K)`-valued functions and precomputed Jacobians. A precomputed `dfdx`
+  must mirror `Y`'s layout with one extra trailing `(D,)` axis, and singleton
+  promotions are tolerated (`(N,)` pairs with `(N, 1, D)`, `(N, 1)` with
+  `(N, D)`); whatever axis moves layout inference applies to a transposed or
+  single-labeled `Y` are replayed on `dfdx`.
+- **Smart output-layout inference** at every public entry point. `Y` is
+  resolved from two signals — the expected sample count identifies the sample
+  axis, and `len(problem.output_names)` (when set) identifies the output
+  axis — through a strict ladder: exact canonical shapes pass silently;
+  unambiguously recoverable layouts (e.g. a transposed `(K, N)` array, or a
+  3-D `(N, K, T)` array whose middle axis matches the labels) are fixed with
+  a `UserWarning` naming the transformation; ambiguous layouts raise. The
+  warnings point at the user's call site (a corrected `stacklevel` across all
+  ten methods). Label rule: a 2-D `Y` of shape `(N, M)` with exactly **one**
+  entry in `problem.output_names` and `M > 1` is read as `M` timepoints of that
+  single output and flows as `(N, M, 1)`; a lone column `(N, 1)` stays canonical
+  as `(N, K=1)` (a scalar output, not a 1-timepoint series — pass `(N, 1, 1)`
+  for that). Without `output_names`, 2-D `Y` still always means `(N, K)`. A 1-D
+  `(N,)` `Y` is accepted as one output regardless of how many names the problem
+  lists.
+- `time_coords` parameter on `PCEResult.to_dataset()` and
+  `DGSMResult.to_dataset()` for labeled time axes on 3-D results
+  (dims `(time, output, param)`).
+
+### Changed
+
+- RS-HDMR now returns `NaN` sensitivity indices (with the existing
+  zero-variance warning) for constant-output slices, matching the
+  package-wide convention used by Sobol and PCE, instead of silent zeros.
+- `analyze_pce` now emits a `UserWarning` when the requested polynomial
+  `order` is automatically reduced to fit the sample budget, and warns on a
+  constant (zero-variance) output.
+- Input-validation errors are now uniform across methods: RS-HDMR, PCE, and
+  DGSM share the same `X`/`Y` contract checks (and error messages) as the
+  given-data methods, and RS-HDMR now also rejects `X`/`Y` row-count
+  mismatches up front.
+- `PCEResult` field layouts now mirror the output layout: `S1`/`ST` are
+  `(..., D)`, `S2` is `(..., D, D)` with a `NaN` diagonal, `coefficients` is
+  `(..., n_terms)` with the term axis last, and `loo_rmse` is per output slice
+  (`()`, `(K,)`, or `(T, K)`). `order` remains a single int — all slices share
+  one basis.
+- `emulate_pce` and `emulate_hdmr` mirror the original training-`Y` rank: a 2-D
+  `(N, T)` single-labeled training `Y` (fit internally as `(N, T, 1)`) now
+  predicts `(N_new, T)` rather than `(N_new, T, 1)`, so `pred - Y_train`
+  broadcasts as expected.
+- PCE Sobol-index extraction is vectorized end to end: `S1`/`ST`/`S2` are
+  masked matmuls over the term axis (`S2` uses an upper-triangle pair mask),
+  replacing the previous Python pair loop.
+
+### Internal
+
+- Bootstrap confidence-interval helpers moved to a shared `jaxgsa._bootstrap`
+  module (previously private to `jaxgsa.sobol` and cross-imported by Morris);
+  PAWN and Borgonovo now reuse the same percentile-CI implementation.
+- All ten result classes now build their `to_dataset()` dims/coords through the
+  shared `_dims_and_coords` helper (including `HDMRResult`, whose per-term
+  arrays swap the trailing `param` dim for `term`), instead of hand-rolling the
+  `param`/`output`/`time` schema; the singleton-axis squeeze after analysis is
+  likewise a single shared `_squeeze_output_axes` helper.
+- `analyze_shapley` now fits through the shared PCE/HDMR cores directly: the
+  default `"pce"` backend reuses `analyze_pce`'s fit without recomputing the
+  `S2` einsum and LOO diagnostic it discards, and both backends validate `Y`
+  and warn about zero-variance slices exactly once.
+
+## 0.1.2
+
+### Added
+
+- `jaxgsa.config.enable_compilation_cache(path, ...)` — opt-in helper that enables JAX's
+  persistent, on-disk compilation cache so compiled kernels are reused across
+  process restarts (parameter sweeps, CI, HPC batches).
+- Configuration guide covering double precision (`jax_enable_x64`) for
+  precision-sensitive Sobol/HSIC estimators and the compilation cache.
+
+### Changed
+
+- Raise the minimum JAX/jaxlib version to 0.6 — the oldest release the test
+  suite is validated against (previously advertised 0.4 but never tested there).
+- Benchmark harness times the SALib HDMR path with the same best-of-N method as
+  the other paths and refreshes the published tables (measured on Apple M1 Pro,
+  JAX 0.10.2); the one-off XLA compile is documented as excluded from the
+  steady-state numbers.
+- The test suite now promotes `DeprecationWarning`/`FutureWarning` to errors
+  (ignore-listing known third-party ones), so upcoming API removals — JAX API
+  changes especially — surface in CI instead of passing silently.
+
+### Fixed
+
+- Benchmark timing helper in `examples/benchmark_all.py` now synchronizes every
+  result array (including bootstrap confidence intervals) before stopping the
+  timer, so no async device work leaks out of the timed region.
+
+## 0.1.1
+
+### Fixed
+
+- HDMR: widen the `scan`/`vmap` loop-variable annotations to `int | Array`
+  so the package type-checks under newer `ty` releases (no runtime change).
+- Loosen the HDMR chunk-size regression test tolerance to absorb
+  floating-point reduction-order differences across jax versions.
+
+### Changed
+
+- Documentation installs jaxgsa from PyPI (`pip install jaxgsa` / `uv add jaxgsa`).
+- Update pinned development/CI dependencies and GitHub Actions; add weekly
+  Dependabot updates for Python dependencies.
+
+## 0.1.0
+
+Initial public release.
+
+`jaxgsa` provides global sensitivity analysis in JAX with seven complementary
+methods:
+
+- **Sobol** indices via Saltelli sampling — first-, total-, and second-order,
+  with JAX-accelerated bootstrap confidence intervals.
+- **RS-HDMR** — B-spline surrogate with ANCOVA decomposition and a built-in
+  emulator; works with any `(X, Y)` sample pairs.
+- **PCE** — Polynomial Chaos Expansion with analytical Sobol indices and
+  leave-one-out cross-validation.
+- **eFAST** — Extended Fourier Amplitude Sensitivity Test.
+- **DGSM** — Derivative-based measures via JAX autodiff, with Poincaré-constant
+  bounds on total Sobol indices.
+- **HSIC** — Hilbert–Schmidt Independence Criterion (kernel-based dependence,
+  R2-HSIC and Total HSIC, permutation p-values).
+- **PAWN** — moment-independent, CDF-based sensitivity via Kolmogorov–Smirnov
+  distances.
+
+All methods support scalar, multi-output, and time-series outputs and export to
+labeled `xarray` Datasets.

jaxgsa-0.4.0/CITATION.cff

@@ -0,0 +1,22 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it using these metadata."
+title: "jaxgsa: Global Sensitivity Analysis in JAX"
+abstract: >-
+  jaxgsa computes global sensitivity indices entirely in JAX, providing Sobol,
+  RS-HDMR, PCE, eFAST, DGSM, HSIC, and PAWN methods with GPU/TPU acceleration.
+type: software
+authors:
+  - family-names: Pessina
+    given-names: Daniele
+    email: danielepessina99@gmail.com
+version: 0.1.0
+date-released: "2026-07-09"
+license: MIT
+repository-code: "https://github.com/DanielePessina/jaxgsa"
+url: "https://danielepessina.github.io/jaxgsa/"
+keywords:
+  - sensitivity-analysis
+  - global-sensitivity-analysis
+  - sobol
+  - jax
+  - uncertainty-quantification

jaxgsa-0.4.0/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to jaxgsa
+
+Thanks for your interest in improving jaxgsa! This guide covers the local setup
+and the checks a pull request is expected to pass.
+
+## Development setup
+
+jaxgsa uses [uv](https://docs.astral.sh/uv/) for environment and dependency
+management.
+
+```bash
+git clone https://github.com/DanielePessina/jaxgsa.git
+cd jaxgsa
+uv sync --extra dev
+```
+
+## Before opening a pull request
+
+Run the same checks CI runs, and make sure they all pass:
+
+```bash
+uv run ruff format .          # format
+uv run ruff check .           # lint
+uv run ty check src/jaxgsa      # type-check
+uv run pytest                 # tests
+```
+
+Please also:
+
+- Add or update tests for any behaviour you change.
+- Keep public APIs documented with Google-style docstrings.
+- Update `CHANGELOG.md` under the unreleased section when user-facing behaviour
+  changes.
+- If you touch the public API, run `uv run python scripts/check_api_docs_coverage.py`
+  so the reference docs stay complete.
+
+## Reporting issues
+
+Please open an issue with a minimal reproducible example, the jaxgsa version, and
+your Python/JAX versions.