From b3246462e1cf4ee56dbac629165c4581ddc9dc57 Mon Sep 17 00:00:00 2001 From: Julian Date: Tue, 23 Jun 2026 06:10:35 +0000 Subject: [PATCH] Modernize pysampling: pyclawd toolkit, src/ layout, pytest, numpy-2 fixes, new docs - Move package to src/pysampling; single-source version in __init__.py - Replace setup.py/MANIFEST.in/Makefile with hatchling pyproject.toml (bundles the Sobol .dat resources; numpy dep; matplotlib [plot] extra) - Adopt pyclawd (.pyclawd/config.py) for test/lint/typecheck/docs - Replace Travis with GitHub Actions (lint, typecheck, 3.10-3.13 matrix) - Convert tests to pytest; cross-check vectorized measures against loop refs - Fix numpy 2.x breakage in sobol.py (np.int -> np.int64), an invalid regex escape, and dead code in util.cdist; raise ValueError for unknown algorithms - Rewrite docs as a cached Sphinx pipeline driven by 'pyclawd docs' (MyST sources -> jupyter-cache -> nbsphinx); README in Markdown --- .github/workflows/ci.yml | 49 ++ .gitignore | 6 +- .pyclawd/config.py | 48 ++ .python-version | 1 + .travis.yml | 11 - CHANGELOG.md | 37 ++ CLAUDE.md | 96 ++++ MANIFEST.in | 1 - Makefile | 9 - README.md | 77 +++ README.rst | 62 --- docs/.gitignore | 13 + docs/Makefile | 20 - docs/README.md | 69 +++ docs/cli.py | 527 ++++++++++++++++++ docs/make.bat | 35 -- docs/source/_static/custom.css | 11 + docs/source/conf.py | 66 +-- docs/source/index.ipynb | 377 ------------- docs/source/index.md | 132 +++++ docs/source/jupytext.toml | 1 + examples/plot_sampling.py | 24 + pyproject.toml | 95 ++++ pysampling/usage.py | 9 - pysampling/version.py | 1 - setup.py | 59 -- src/pysampling/__init__.py | 14 + .../pysampling/algorithms}/__init__.py | 0 .../pysampling}/algorithms/halton.py | 1 - .../pysampling}/algorithms/lhs.py | 23 +- .../pysampling}/algorithms/random.py | 1 - .../pysampling}/algorithms/sobol.py | 48 +- {pysampling => src/pysampling}/measures.py | 44 +- .../__init__.py => src/pysampling/py.typed | 0 .../pysampling}/resources/sobol_burkardt.dat | 0 .../pysampling}/resources/sobol_joekuo.dat | 0 .../pysampling}/resources/sobol_matlab.dat | 0 {pysampling => src/pysampling}/sample.py | 8 +- {pysampling => src/pysampling}/sampling.py | 3 +- {pysampling => src/pysampling}/util.py | 19 +- tests/test_discrepancy.py | 126 ++--- tests/test_sampling.py | 25 +- tests/test_sobol.py | 38 +- tests/test_suite.py | 19 - tests/util.py | 6 +- ~$logo.pptx | Bin 165 -> 0 bytes 46 files changed, 1374 insertions(+), 837 deletions(-) create mode 100644 .github/workflows/ci.yml create mode 100644 .pyclawd/config.py create mode 100644 .python-version delete mode 100644 .travis.yml create mode 100644 CHANGELOG.md create mode 100644 CLAUDE.md delete mode 100644 MANIFEST.in delete mode 100644 Makefile create mode 100644 README.md delete mode 100644 README.rst create mode 100644 docs/.gitignore delete mode 100644 docs/Makefile create mode 100644 docs/README.md create mode 100644 docs/cli.py delete mode 100644 docs/make.bat create mode 100644 docs/source/_static/custom.css delete mode 100644 docs/source/index.ipynb create mode 100644 docs/source/index.md create mode 100644 docs/source/jupytext.toml create mode 100644 examples/plot_sampling.py create mode 100644 pyproject.toml delete mode 100644 pysampling/usage.py delete mode 100644 pysampling/version.py delete mode 100644 setup.py create mode 100644 src/pysampling/__init__.py rename {pysampling => src/pysampling/algorithms}/__init__.py (100%) rename {pysampling => src/pysampling}/algorithms/halton.py (99%) rename {pysampling => src/pysampling}/algorithms/lhs.py (72%) rename {pysampling => src/pysampling}/algorithms/random.py (99%) rename {pysampling => src/pysampling}/algorithms/sobol.py (74%) rename {pysampling => src/pysampling}/measures.py (59%) rename pysampling/algorithms/__init__.py => src/pysampling/py.typed (100%) rename {pysampling => src/pysampling}/resources/sobol_burkardt.dat (100%) rename {pysampling => src/pysampling}/resources/sobol_joekuo.dat (100%) rename {pysampling => src/pysampling}/resources/sobol_matlab.dat (100%) rename {pysampling => src/pysampling}/sample.py (75%) rename {pysampling => src/pysampling}/sampling.py (97%) rename {pysampling => src/pysampling}/util.py (67%) delete mode 100644 tests/test_suite.py delete mode 100644 ~$logo.pptx diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..0ef4dbc --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,49 @@ +name: CI + +on: + push: + branches: [master, main] + pull_request: + +# These jobs mirror `pyclawd check` (format-check -> lint -> typecheck -> test): +# the same tools (ruff check, ruff format --check, mypy, pytest) run here and +# locally, so a green `pyclawd check` predicts a green CI. CI deliberately does +# NOT depend on pyclawd being installed/published — it calls the tools directly. +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v5 + - name: Ruff lint + run: uvx ruff check . + - name: Ruff format check + run: uvx ruff format --check . + + typecheck: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - run: python -m pip install --upgrade pip mypy + - run: python -m pip install -e . + - name: Mypy + run: mypy src + + test: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.10", "3.11", "3.12", "3.13"] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - run: python -m pip install --upgrade pip pytest + - run: python -m pip install -e . + - name: Pytest + run: pytest diff --git a/.gitignore b/.gitignore index 76b8ee6..ad60ce4 100644 --- a/.gitignore +++ b/.gitignore @@ -77,9 +77,6 @@ target/ # Jupyter Notebook .ipynb_checkpoints -# pyenv -.python-version - # celery beat schedule file celerybeat-schedule @@ -105,5 +102,6 @@ venv.bak/ # mkdocs documentation /site -# mypy +# mypy / ruff .mypy_cache/ +.ruff_cache/ diff --git a/.pyclawd/config.py b/.pyclawd/config.py new file mode 100644 index 0000000..837c784 --- /dev/null +++ b/.pyclawd/config.py @@ -0,0 +1,48 @@ +"""pysampling's pyclawd config — drives `pyclawd test/lint/typecheck/docs/...` for this repo.""" + +from pyclawd import DocsConfig, DoctorConfig, Project, QualityConfig, TestConfig + +project = Project( + name="pysampling", + conda_env="default", + root_markers=["pyproject.toml"], + # Where pyclawd writes this project's transient files (run logs, junit, scratch). + work_dir="/tmp/pysampling", + # Default directory `pyclawd ls` lists (the code/source root). + src_dir="src", + quality=QualityConfig( + lint_cmd=["ruff", "check"], + lint_fix_cmd=["ruff", "check", "--fix"], + format_cmd=["ruff", "format"], + format_check_cmd=["ruff", "format", "--check"], + typecheck_cmd=["mypy", "src"], + check_sequence=["format-check", "lint", "typecheck", "test"], + ), + # Docs build runs in the project env: `pip install -e . --group docs`, then + # `pyclawd docs build` → `python docs/cli.py all`. (Swap `runner` for an + # isolated env, e.g. uvx, if you'd rather not install the docs deps here.) + docs=DocsConfig( + runner=["python", "docs/cli.py"], + source_dir="docs/source", + cache_dir="docs/.jupyter_cache", + cache_db="docs/.jupyter_cache/global.db", + build_html="docs/build/html", + branch="master", + ), + test=TestConfig( + tests_dir="tests/", + classname_prefix="tests.", + integration_files=[], + markers={"default": "not slow", "fast": "not slow", "all": ""}, + ), + doctor=DoctorConfig( + core_deps=["numpy"], + dev_deps=["pytest"], + tool_files=[], + binaries=[ + ("ruff", "pip install ruff"), + ("mypy", "pip install mypy"), + ("pandoc", "conda install -c conda-forge pandoc"), # nbsphinx HTML render + ], + ), +) diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..e4fba21 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index e69f880..0000000 --- a/.travis.yml +++ /dev/null @@ -1,11 +0,0 @@ -language: python -python: - - "3.7" - -install: - - pip install . - - -script: - - cd tests - - python test_suite.py diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..f7e6170 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,37 @@ +# Changelog + +All notable changes to this project are documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/), and this +project adheres to [Semantic Versioning](https://semver.org/). + +## [Unreleased] + +### Added +- Modern Sphinx documentation under `docs/` with a cached build pipeline + (`pyclawd docs build`): MyST Markdown sources → executed notebooks + (jupyter-cache) → Sphinx + nbsphinx HTML. The builder is the standalone + `docs/cli.py`, run with the project Python; its toolchain is the `docs` + dependency group (`pip install -e . --group docs`). + +### Changed +- Adopted the [pyclawd](https://github.com/anyoptimization) dev toolkit and moved + to a modern `src/` layout with a `pyproject.toml` (hatchling) build. +- Replaced Travis CI with GitHub Actions (`lint`, `typecheck`, `test` matrix). +- Converted the test suite from bespoke `unittest` runners to pytest. +- Replaced the ancient single-`index.ipynb` Sphinx setup with the new docs + pipeline above. +- Rewrote the README in Markdown. + +### Fixed +- `SobolSampling` crashed on NumPy 2.x (`np.int` was removed); now uses + `np.int64`. +- Fixed an invalid regex escape in the Sobol resource parser (`"\s"` -> `r"\s"`). +- Removed unreachable/dead branches and an undefined return in `util.cdist`; the + alternative implementations are now selectable via `"matmul"` / `"broadcast"`. + +## [0.1.2] + +### Added +- Initial public release: random, Latin Hypercube, Halton and Sobol sampling + plus discrepancy/uniformity measures. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..17cc5e6 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,96 @@ +# CLAUDE.md — pysampling + +`pysampling` generates well-spread point sets in the unit hypercube `[0, 1]^d` +(random, Latin Hypercube, Halton, Sobol) and provides discrepancy/uniformity +measures to assess them. `README.md` is the human-facing overview; this file is +the working contract for AI agents. + +## This project follows pyclawd + +Development is driven by [pyclawd](https://github.com/anyoptimization) — a +project-generic Python dev-task CLI. The whole project is described by one file, +[`.pyclawd/config.py`](.pyclawd/config.py), and humans and agents drive it the +same way. **pyclawd is expected to already be installed in your environment** +(it is not vendored into this repo, and neither are its agent skills — install +those once per machine with `pyclawd skills install` if you want them). + +Read `.pyclawd/config.py` before assuming how anything is wired — it is the +single source of truth for the env, paths, and checks. + +## Critical rule — how to run Python + +**ALWAYS run Python through `pyclawd python`. NEVER call bare `python` / `python -c`.** + +```bash +pyclawd python script.py # run a script +pyclawd python -m pytest ... # run a module +pyclawd python -c "import pysampling" # quick check +``` + +`pyclawd python` runs in the project's configured env (`conda_env` in +`.pyclawd/config.py`) with the repo on `PYTHONPATH`. Bare `python` misses the +env and the in-tree source. + +## Commands + +| Task | Command | +|---|---| +| Health-check the dev env | `pyclawd doctor` | +| Run Python in the env | `pyclawd python ` · `-m ` · `-c ` | +| Fast smoke tests | `pyclawd test fast` | +| Default test gate | `pyclawd test run` | +| Select tests | `pyclawd test -k ` · `pyclawd test tests/path::node` | +| Lint / autofix | `pyclawd lint` · `pyclawd lint --fix` | +| Format / check | `pyclawd format` · `pyclawd format --check` | +| Type-check | `pyclawd typecheck` | +| **Aggregate quality gate** | `pyclawd check` | +| Build a source/wheel dist | `pyclawd dist` | +| Build / serve the docs | `pyclawd docs build` · `pyclawd docs serve` | + +`pyclawd check` runs **format-check → lint → typecheck → test**, fail-fast — the +canonical "am I done?" gate. CI (`.github/workflows/ci.yml`) mirrors it with the +same tools, so a green `pyclawd check` predicts green CI. + +## Project layout + +``` +src/pysampling/ # the package (src layout) + sample.py # sample(algorithm, n_points, n_dim, ...) entry point + sampling.py # abstract Sampling base class + algorithms/ # random, lhs, halton, sobol implementations + measures.py # discrepancy / uniformity measures + util.py # cdist, prime sieve, resource paths + resources/*.dat # Sobol direction-number tables (bundled package data) +tests/ # pytest suite (+ resources/ for fixtures) +examples/ # runnable demos (plot_sampling.py) +``` + +The single source of truth for the version is +`src/pysampling/__init__.py::__version__` (hatchling reads it). Bump it there; do +not reintroduce a separate `version.py`. + +## Conventions & boundaries + +### Always +- Run code via `pyclawd python` — never bare `python`. +- Run `pyclawd doctor` first when the env looks off or tests fail to import. +- **Run `pyclawd check` before declaring work done.** +- Fix the *cause* of a failing test, not the assertion — use tolerances for + floats and pinned seeds for stochastic tests (`sample(..., seed=...)`). +- Each discrepancy measure in `measures.py` has a slow loop reference in + `tests/test_discrepancy.py`; keep them in agreement when you touch either. + +### Ask first +- Committing, pushing, opening PRs. +- Changing `.pyclawd/config.py`, dependencies, or the public API (`sample`). + +### Never +- Never call bare `python`/`pip` outside the project env. +- Never weaken or delete a test to make a suite pass. +- Never leave the tree with a failing `pyclawd check`. + +## How you know you're done + +- `pyclawd check` is green (format-check, lint, typecheck, tests all ✓). +- `pyclawd doctor` exits 0. +- Behavior is verified by tests, not just by inspection. diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index f970b91..0000000 --- a/MANIFEST.in +++ /dev/null @@ -1 +0,0 @@ -recursive-include pysampling *.py *.dat diff --git a/Makefile b/Makefile deleted file mode 100644 index 9ff7f2e..0000000 --- a/Makefile +++ /dev/null @@ -1,9 +0,0 @@ -clean: - rm -rf build dist pysampling.egg-info - -dist: - python setup.py sdist bdist_wheel - -install: - pip install . - diff --git a/README.md b/README.md new file mode 100644 index 0000000..2a92df9 --- /dev/null +++ b/README.md @@ -0,0 +1,77 @@ +# pysampling + +[![python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/) +[![license](https://img.shields.io/badge/license-apache-orange.svg)](https://www.apache.org/licenses/LICENSE-2.0) + +Sampling methods for design of experiments in Python. `pysampling` generates +well-spread point sets in the unit hypercube `[0, 1]^d` and provides a suite of +measures to assess their uniformity. + +Detailed documentation: https://anyoptimization.com/projects/pysampling + +## Algorithms + +| Key | Method | +|------------|-------------------------| +| `random` | Uniform random sampling | +| `lhs` | Latin Hypercube Sampling | +| `halton` | Halton sequence | +| `sobol` | Sobol sequence | + +## Installation + +```bash +pip install -U pysampling +``` + +## Usage + +Import the `sample` function and pick an algorithm. Here we draw 50 points in 2 +dimensions with Latin Hypercube Sampling: + +```python +from pysampling.sample import sample + +X = sample("lhs", 50, 2) +``` + +To visualize the result (requires the optional `plot` extra, `pip install +pysampling[plot]`): + +```python +import matplotlib.pyplot as plt + +plt.scatter(X[:, 0], X[:, 1], s=30, facecolors="none", edgecolors="r") +plt.show() +``` + +See [`examples/plot_sampling.py`](examples/plot_sampling.py) for a runnable demo. + +## Development + +This project uses [pyclawd](https://github.com/anyoptimization) as its dev +toolkit. + +```bash +pip install -e . --group dev +pyclawd check # format-check -> lint -> typecheck -> test +pyclawd test fast # quick test run +``` + +### Documentation + +The docs are built by a cached pipeline (see [`docs/`](docs/)): + +```bash +pip install -e . --group docs # one-time: install the docs toolchain +pyclawd docs build # compile -> execute (cached) -> render HTML +pyclawd docs serve # serve docs/build/html locally +``` + +## Contact + +Julian Blank — blankjul@outlook.com + +## License + +Apache License 2.0 — see [LICENSE](LICENSE). diff --git a/README.rst b/README.rst deleted file mode 100644 index b7c3bfd..0000000 --- a/README.rst +++ /dev/null @@ -1,62 +0,0 @@ -pysampling -==================================================================== - -You can find the detailed documentation here: https://anyoptimization.com/projects/pysampling - - -|python| |license| - - - -.. |python| image:: https://img.shields.io/badge/python-3.6-blue.svg - :alt: python 3.6 - -.. |license| image:: https://img.shields.io/badge/license-apache-orange.svg - :alt: license apache - :target: https://www.apache.org/licenses/LICENSE-2.0 - - - -Installation -============ - -The framework is available at the PyPi Repository: - -.. code-block:: bash - - pip install -U pysampling - - -Usage -===== - -The method to be used for sampling using different algorithm must be -import from pysampling.sample. Here, we use Latin Hypercube Sampling to -generate 50 points in 2 dimensions. - -.. code:: python - - import matplotlib.pyplot as plt - from pysampling.sample import sample - - X = sample("lhs", 50, 2) - - plt.scatter(X[:, 0], X[:, 1], s=30, facecolors='none', edgecolors='r') - plt.show() - - - -Contact -======= - - -Feel free to contact me if you have any question: - -:: - - Julian Blank (blankjul [at] egr.msu.edu) - Michigan State University - Computational Optimization and Innovation Laboratory (COIN) - East Lansing, MI 48824, USA - - diff --git a/docs/.gitignore b/docs/.gitignore new file mode 100644 index 0000000..80af3f4 --- /dev/null +++ b/docs/.gitignore @@ -0,0 +1,13 @@ +# Rendered HTML + Sphinx doctrees +build/ + +# jupyter-cache (executed outputs live ONLY here, never in git) +.jupyter_cache/ +.virtual_documents/ + +# Notebooks generated from .md sources by jupytext (sources are the .md files) +source/**/*.ipynb + +# Packaging / bytecode for the docs runner +*.egg-info/ +__pycache__/ diff --git a/docs/Makefile b/docs/Makefile deleted file mode 100644 index d0c3cbf..0000000 --- a/docs/Makefile +++ /dev/null @@ -1,20 +0,0 @@ -# Minimal makefile for Sphinx documentation -# - -# You can set these variables from the command line, and also -# from the environment for the first two. -SPHINXOPTS ?= -SPHINXBUILD ?= sphinx-build -SOURCEDIR = source -BUILDDIR = build - -# Put it first so that "make" without argument is like "make help". -help: - @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - -.PHONY: help Makefile - -# Catch-all target: route all unknown targets to Sphinx using the new -# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). -%: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..a8aaf38 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,69 @@ +# pysampling documentation builder + +The documentation pipeline for pysampling. `pyclawd docs` delegates to this +builder (see `DocsConfig.runner` in `../.pyclawd/config.py`), which is just the +standalone script `cli.py` run with the project's Python: + + runner = ["python", "docs/cli.py"] + +The docs toolchain (sphinx, nbsphinx, jupytext, jupyter-cache, …) is the `docs` +dependency group in the project's `pyproject.toml`. Install it once into your +environment: + +```bash +pip install -e . --group docs +``` + +> The runner is just a command list — if you'd rather keep the docs deps out of +> your project env, point `runner` at an isolated env instead, e.g. +> `["uvx", "--from", "./docs", "..."]`, `["conda", "run", "-n", "docs", "python", "cli.py"]`, +> or a dedicated venv. pyclawd does not care which. + +## Quick start + +From the project root: + +```bash +pyclawd docs build # compile → execute (cached) → render HTML +pyclawd docs serve # serve docs/build/html locally +``` + +The built site lands at `docs/build/html/index.html`. + +## How it works + +Sources are MyST Markdown (`source/**/*.md`). The pipeline: + +1. **compile** — `jupytext` converts changed `.md` → `.ipynb`. +2. **run** — notebooks execute in parallel; successes are cached by + `jupyter-cache`, so unchanged notebooks are skipped on the next build. +3. **render** — Sphinx + nbsphinx render the executed notebooks to HTML. + Sphinx itself never executes (`nbsphinx_execute = 'never'`). + +Execution and rendering are separate, so a render-only fix re-renders in seconds +without re-executing. + +## Commands + +Run directly (or via the matching `pyclawd docs `): + +```bash +python docs/cli.py all [--force] [--continue] # full pipeline +python docs/cli.py compile [--force] [files...] +python docs/cli.py run [--force] [files...] +python docs/cli.py build [--fast] # render HTML only +python docs/cli.py failures [--full] +python docs/cli.py exec # debug ONE notebook +python docs/cli.py timings +python docs/cli.py clean +``` + +## Authoring + +- Edit the **`.md`** sources, never the generated `.ipynb` (they are gitignored). +- Prose-only pages render instantly; add executable code with MyST + ` ```{code-cell} ipython3 ` blocks. +- Structural pages (`index.rst`, `api.rst`) are reStructuredText. + +Environment overrides: `PYSAMPLING_DOCS_TIMEOUT` (per-cell seconds), +`PYSAMPLING_DOCS_JOBS` (parallel workers). diff --git a/docs/cli.py b/docs/cli.py new file mode 100644 index 0000000..c31aff3 --- /dev/null +++ b/docs/cli.py @@ -0,0 +1,527 @@ +#!/usr/bin/env python3 +"""pysampling documentation builder CLI. + +A standalone, isolated documentation pipeline driven by ``uvx --from ./docs +pysampling-docs``. pyclawd's ``pyclawd docs`` group delegates to this CLI, so all +the heavy docs dependencies (sphinx/nbsphinx/jupyter-cache/...) live in this +isolated env and never pollute the project itself. + +Pipeline: MyST ``.md`` sources are compiled to ``.ipynb`` (jupytext), executed +with a content-addressed cache (jupyter-cache, unchanged notebooks are skipped), +then rendered to HTML by Sphinx + nbsphinx. + +Adapted from the pymoo docs builder. +""" + +import argparse +import glob +import json +import logging +import os +import re +import shutil +import sqlite3 +import subprocess +import sys +import time +from pathlib import Path + +log = logging.getLogger("pysampling-docs") + + +def _setup_logging(): + """Structured logs: `HH:MM:SS LEVEL message` (with [notebook] context).""" + if log.handlers: + return + handler = logging.StreamHandler(sys.stdout) + handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-5s %(message)s", "%H:%M:%S")) + log.addHandler(handler) + log.setLevel(logging.INFO) + log.propagate = False + + +# Per-cell execution timeout (s). 30s (nbclient default) can be too low; raise it +# so long-but-legitimate cells don't time out. Override via PYSAMPLING_DOCS_TIMEOUT. +EXEC_TIMEOUT = os.environ.get("PYSAMPLING_DOCS_TIMEOUT", "120") + +# Number of notebooks executed in parallel. Default = cores - 2 (min 1); override +# via PYSAMPLING_DOCS_JOBS to keep small machines responsive. +EXEC_JOBS = os.environ.get("PYSAMPLING_DOCS_JOBS") or str(max(1, (os.cpu_count() or 3) - 2)) + + +def read_timings(cache_dir="."): + """Map notebook abspath -> last execution time (seconds) from the + jupyter-cache DB. Empty dict if the cache doesn't exist yet.""" + db = Path(cache_dir) / ".jupyter_cache" / "global.db" + if not db.exists(): + return {} + timings = {} + con = sqlite3.connect(str(db)) + try: + for uri, data in con.execute("SELECT uri, data FROM nbcache"): + try: + secs = json.loads(data or "{}").get("execution_seconds") + except (ValueError, TypeError): + secs = None + if secs is not None: + timings[uri] = secs + finally: + con.close() + return timings + + +def read_failures(cache_dir="."): + """Map notebook abspath -> traceback (ANSI-stripped) for notebooks whose last + execution failed. jupyter-cache stores these in nbproject.traceback.""" + db = Path(cache_dir) / ".jupyter_cache" / "global.db" + if not db.exists(): + return {} + failures = {} + con = sqlite3.connect(str(db)) + try: + q = "SELECT uri, traceback FROM nbproject WHERE traceback IS NOT NULL AND traceback != ''" + for uri, tb in con.execute(q): + failures[uri] = re.sub(r"\x1b\[[0-9;]*m", "", tb) + finally: + con.close() + return failures + + +def _error_line(tb): + """The most informative line of a traceback (the exception).""" + errs = [ln.strip() for ln in tb.splitlines() if re.search(r"(Error|Exception|Timeout\w*):", ln)] + if errs: + return errs[-1] + lines = [ln for ln in tb.splitlines() if ln.strip()] + return lines[-1].strip() if lines else "(unknown)" + + +def show_failures(full=False): + """Print failed notebooks and their errors (full tracebacks with --full).""" + failures = read_failures(".") + if not failures: + print("✅ No failed notebooks recorded in the cache.") + return + print(f"❌ {len(failures)} failed notebook(s):") + for uri in sorted(failures): + name = uri.split("/docs/source/")[-1] + if full: + print(f"\n=== {name} ===\n{failures[uri].strip()}") + else: + print(f" {name}: {_error_line(failures[uri])[:140]}") + + +def show_timings(): + """Print all cached notebook execution times (slowest first).""" + timings = read_timings(".") + if not timings: + print("No cache timings yet — run a build first.") + return + rows = sorted(((s, u) for u, s in timings.items()), reverse=True) + total = sum(s for s, _ in rows) + print(f"⏱ Notebook execution time (cached) — total {total:.1f}s across {len(rows)} notebooks:") + src = Path("source").resolve() + for secs, uri in rows: + try: + uri = str(Path(uri).relative_to(src)) + except ValueError: + pass + print(f" {secs:7.1f}s {uri}") + + +def run_command(cmd, cwd=None, check=True): + """Run a command and stream output to the console.""" + if isinstance(cmd, str): + cmd = cmd.split() + print(f"$ {' '.join(cmd)}") + result = subprocess.run(cmd, cwd=cwd, check=False) + if check and result.returncode != 0: + sys.exit(result.returncode) + return result + + +def clean_docs(): + """Remove generated documentation files (keeps the execution cache).""" + print("🧹 Cleaning documentation files...") + build_dir = Path("build") + if build_dir.exists(): + shutil.rmtree(build_dir) + print(f"Removed {build_dir}") + for nb_file in glob.glob("source/**/*.ipynb", recursive=True): + nb_path = Path(nb_file) + if nb_path.with_suffix(".md").exists(): # generated from a .md → safe to drop + nb_path.unlink() + print(f"Removed generated notebook: {nb_file}") + print("✅ Clean completed") + + +def install_project(): + """Install the parent package (editable) so autodoc can import it.""" + try: + import pysampling # noqa: F401 + + print("✅ pysampling is available") + return True + except ImportError: + print("📦 Installing pysampling in development mode...") + parent_dir = Path("..").resolve() + if (parent_dir / "pyproject.toml").exists(): + run_command(["python", "-m", "pip", "install", "-e", str(parent_dir)], check=False) + return True + print("⚠️ pysampling source not found in parent directory — API docs may fail") + return False + + +def compile_notebooks(force=False, files=None): + """Convert MyST ``.md`` sources to ``.ipynb`` notebooks (jupytext).""" + print("📝 Starting notebook compilation...") + if files: + md_to_process = files + print(f"📋 Processing {len(md_to_process)} specified files") + else: + all_md_files = glob.glob("source/**/*.md", recursive=True) + if force: + md_to_process = all_md_files + print(f"🔄 Force mode: processing all {len(md_to_process)} markdown files") + else: + # Only (re)compile sources that are new or changed since their .ipynb. + md_to_process = [] + for md_file in all_md_files: + nb_file = Path(md_file).with_suffix(".ipynb") + if not nb_file.exists() or Path(md_file).stat().st_mtime > nb_file.stat().st_mtime: + md_to_process.append(md_file) + print(f"📋 {len(md_to_process)} changed/new of {len(all_md_files)} markdown files") + + if not md_to_process: + print("✅ All notebooks already exist. Use --force to regenerate all.") + return + + run_command(["python", "-m", "jupytext", "--to", "notebook", *md_to_process]) + + # Normalize the kernel to one that exists in the build env. + import nbformat + + fixed = 0 + for md in md_to_process: + nb_path = Path(md).with_suffix(".ipynb") + if not nb_path.exists(): + continue + nb = nbformat.read(nb_path, 4) + if nb.metadata.get("kernelspec", {}).get("name") != "python3": + nb.metadata["kernelspec"] = {"name": "python3", "display_name": "Python 3"} + nbformat.write(nb, nb_path) + fixed += 1 + if fixed: + print(f"🔧 Normalized kernel → python3 in {fixed} notebook(s)") + print("✅ Notebook compilation completed") + + +def _execute_one(nb_path, timeout): + """Execute ONE notebook (kernel forced to python3) and write outputs back. + Returns (ok, seconds, error_or_None). Runs in its own worker process.""" + import nbformat + from nbclient import NotebookClient + from nbclient.exceptions import CellExecutionError + + nb = nbformat.read(nb_path, 4) + nb.metadata["kernelspec"] = {"name": "python3", "display_name": "Python 3"} + t0 = time.monotonic() + try: + NotebookClient( + nb, + timeout=int(timeout), + kernel_name="python3", + resources={"metadata": {"path": str(Path(nb_path).parent)}}, + ).execute() + nbformat.write(nb, nb_path) + return True, time.monotonic() - t0, None + except CellExecutionError as exc: + nbformat.write(nb, nb_path) # keep error output for backtrack + lines = [ln for ln in str(exc).strip().splitlines() if ln.strip()] + return False, time.monotonic() - t0, (lines[-1] if lines else "CellExecutionError")[:140] + except Exception as exc: # kernel death, timeout, … + return False, time.monotonic() - t0, f"{type(exc).__name__}: {exc}"[:140] + + +def run_notebooks(force=False, files=None): + """Execute notebooks in parallel, caching successes (jupyter-cache STORE). + + Only stale notebooks run; successes are cached and every notebook is hydrated + with outputs for nbsphinx. Executed outputs never reach git. + """ + from concurrent.futures import ProcessPoolExecutor, as_completed + + from jupyter_cache import get_cache + + if files: + nb_files = [str(Path(f).with_suffix(".ipynb")) for f in files] + else: + all_md = glob.glob("source/**/*.md", recursive=True) + nb_files = [str(Path(md).with_suffix(".ipynb")) for md in all_md] + nb_files = [str(Path(nb).resolve()) for nb in nb_files if Path(nb).exists()] + if not nb_files: + log.info("no notebooks to execute (run 'compile' first)") + return 0 + + cache = get_cache(".jupyter_cache") + jobs = int(EXEC_JOBS) + src_root = str(Path("source").resolve()) + os.sep + + stale, n_cached = [], 0 + for nb in nb_files: + if force: + stale.append(nb) + continue + try: + cache.match_cache_file(nb) + n_cached += 1 + except KeyError: + stale.append(nb) + + log.info( + "execute · %d stale · %d cached · %d workers · %ss/cell timeout", + len(stale), n_cached, jobs, EXEC_TIMEOUT, + ) + + n_ok = n_fail = 0 + with ProcessPoolExecutor(max_workers=jobs) as pool: + futures = {pool.submit(_execute_one, nb, EXEC_TIMEOUT): nb for nb in stale} + for fut in as_completed(futures): + nb = futures[fut] + name = nb.replace(src_root, "") + ok, secs, err = fut.result() + if ok: + cache.cache_notebook_file(nb, data={"execution_seconds": secs}, overwrite=True) + log.info("[%s] ok · %.1fs", name, secs) + n_ok += 1 + else: + log.error("[%s] failed · %s", name, err) + n_fail += 1 + + for nb in nb_files: + try: + cache.merge_match_into_file(nb) + except Exception: + pass # not cached (a failure) — leave it output-less + + (log.warning if n_fail else log.info)( + "done · %d ok · %d failed · %d reused", n_ok, n_fail, n_cached + ) + return n_fail + + +def exec_single(page): + """Execute ONE notebook directly (no cache, no pool) and show its error. + + The debug loop: run one → read the traceback → fix the .md → run again. + """ + name = page.removesuffix(".ipynb").removesuffix(".md") + md = f"{name}.md" if name.startswith("source/") else f"source/{name}.md" + if not Path(md).exists(): + print(f"❌ source not found: {md}") + sys.exit(2) + nb = Path(md).with_suffix(".ipynb") + + run_command(["python", "-m", "jupytext", "--to", "notebook", md]) + import nbformat + + n = nbformat.read(nb, 4) + n.metadata["kernelspec"] = {"name": "python3", "display_name": "Python 3"} + nbformat.write(n, nb) + + print(f"\n⚡ Executing {nb} (timeout {EXEC_TIMEOUT}s/cell)...\n") + result = run_command( + [ + "python", "-m", "jupyter", "nbconvert", "--to", "notebook", "--execute", + "--inplace", f"--ExecutePreprocessor.timeout={EXEC_TIMEOUT}", str(nb), + ], + check=False, + ) + if result.returncode == 0: + print(f"\n✅ {nb} executed cleanly") + else: + print(f"\n❌ {nb} failed — full traceback above. Fix {md} and re-run.") + sys.exit(result.returncode) + + +def _summarize_render(warnfile: Path, renderlog: Path, returncode: int) -> int: + """Turn Sphinx's raw warning stream into a structured render verdict.""" + lines = [] + if warnfile.exists(): + lines = [ln.strip() for ln in warnfile.read_text(errors="replace").splitlines() if ln.strip()] + + seen, errors, warnings = set(), [], [] + for ln in lines: + if ln in seen: + continue + seen.add(ln) + (errors if "ERROR" in ln or "CRITICAL" in ln else warnings).append(ln) + + n = len(errors) + len(warnings) + if returncode != 0: + log.error("render · sphinx exited %d — HTML may be incomplete", returncode) + if n == 0: + log.info("render · clean · 0 warnings · log %s", renderlog) + return 0 + + emit = log.error if errors else log.warning + emit( + "render · %d unique issue(s) · %d error(s) · %d warning(s) · warnlog %s · log %s", + n, len(errors), len(warnings), warnfile, renderlog, + ) + for ln in (errors + warnings)[:30]: + emit(" %s", ln) + if n > 30: + emit(" … %d more — see %s", n - 30, warnfile) + return n + + +def build_html(): + """Render HTML documentation with Sphinx + nbsphinx.""" + print("🏗️ Building HTML documentation...") + build_dir = Path("build") + build_dir.mkdir(exist_ok=True) + + warnfile = build_dir / "sphinx-warnings.log" + renderlog = build_dir / "sphinx-render.log" + cmd = [ + "python", "-m", "sphinx", + "-b", "html", + "-d", "build/doctrees", + "--keep-going", + "-w", str(warnfile), + "source", + "build/html", + ] + print(f"$ {' '.join(cmd)}") + log.info("render · sphinx starting · full log %s", renderlog) + with open(renderlog, "w") as rf: + proc = subprocess.Popen( + cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1 + ) + for line in proc.stdout: + sys.stdout.write(line) + rf.write(line) + proc.wait() + + n_warn = _summarize_render(warnfile, renderlog, proc.returncode) + if proc.returncode != 0: + sys.exit(proc.returncode) + + verdict = ( + "✅ HTML build completed" + if n_warn == 0 + else f"⚠️ HTML build completed with {n_warn} render warning(s) — see {warnfile}" + ) + print(verdict) + print(f"📖 Documentation available at: {(build_dir / 'html' / 'index.html').resolve()}") + + +def serve_docs(port=8000): + """Serve the built documentation locally.""" + html_dir = Path("build/html") + if not html_dir.exists(): + print("❌ No built documentation found. Run 'build' first.") + sys.exit(1) + print(f"🌐 Serving documentation at http://localhost:{port} (Ctrl+C to stop)") + try: + run_command(["python", "-m", "http.server", str(port)], cwd=html_dir) + except KeyboardInterrupt: + print("\n👋 Server stopped") + + +def _maybe_chdir_to_docs(): + """Run from the docs directory regardless of where the command was invoked.""" + if Path("source").is_dir(): + return + for candidate in [Path("docs"), Path("../docs"), Path("../../docs")]: + if (candidate / "source").exists(): + target = candidate.resolve() + os.chdir(target) + print(f"📁 Changed to docs directory: {target}") + return + print("❌ Could not find a docs directory containing 'source/'") + sys.exit(1) + + +def main(): + parser = argparse.ArgumentParser(description="pysampling documentation builder") + sub = parser.add_subparsers(dest="command", help="Available commands") + + sub.add_parser("clean", help="Remove generated files (keeps the cache)") + + p_compile = sub.add_parser("compile", help="Convert .md to .ipynb") + p_compile.add_argument("--force", action="store_true", help="Recompile all files") + p_compile.add_argument("files", nargs="*", help="Specific files (optional)") + + p_run = sub.add_parser("run", help="Execute notebooks (cached, parallel, skip-unchanged)") + p_run.add_argument("--force", action="store_true", help="Re-execute all notebooks") + p_run.add_argument("files", nargs="*", help="Specific files (optional)") + p_run.add_argument("--continue", dest="cont", action="store_true", help="Don't exit non-zero on failure") + + # `build` renders HTML ONLY (from already-executed notebooks). The full + # compile→run→render pipeline is `all`. This mirrors what pyclawd expects: + # `pyclawd docs render` → `build [--fast]`, `pyclawd docs build` → `all`. + p_build = sub.add_parser("build", help="Render HTML from executed notebooks (no execution)") + p_build.add_argument("--fast", action="store_true", help="Skip notebooks (smoke render)") + + p_all = sub.add_parser("all", help="Compile → run → render HTML") + p_all.add_argument("--force", action="store_true", help="Recompile and re-execute everything") + p_all.add_argument("--continue", dest="cont", action="store_true", help="Render even if notebooks failed") + + p_serve = sub.add_parser("serve", help="Serve built HTML locally") + p_serve.add_argument("--port", type=int, default=8000) + + sub.add_parser("timings", help="Cached per-notebook execution times (slowest first)") + p_fail = sub.add_parser("failures", help="Notebooks whose last execution failed") + p_fail.add_argument("--full", action="store_true", help="Show full tracebacks") + p_exec = sub.add_parser("exec", help="Execute ONE notebook directly and show its error") + p_exec.add_argument("page", help="Notebook page, e.g. getting_started") + + args = parser.parse_args() + _setup_logging() + _maybe_chdir_to_docs() + + if args.command in {"compile", "run", "build", "exec", "all"}: + install_project() + + if args.command == "clean": + clean_docs() + elif args.command == "compile": + compile_notebooks(force=args.force, files=args.files) + elif args.command == "run": + n_fail = run_notebooks(force=args.force, files=args.files) + if n_fail and not args.cont: + sys.exit(1) + elif args.command == "build": + if args.fast: + os.environ["PYSAMPLING_DOCS_FAST_MODE"] = "1" + print("⚡ Fast render mode: excluding notebooks") + build_html() + elif args.command == "all": + compile_notebooks(force=args.force) + n_fail = run_notebooks(force=args.force) + if n_fail and not args.cont: + log.error( + "%d notebook(s) failed — NOT building HTML. " + "Fix them (`failures` / `exec `) or pass --continue.", + n_fail, + ) + sys.exit(1) + build_html() + log.info("documentation build complete") + elif args.command == "serve": + serve_docs(args.port) + elif args.command == "timings": + show_timings() + elif args.command == "failures": + show_failures(full=args.full) + elif args.command == "exec": + exec_single(args.page) + else: + parser.print_help() + sys.exit(2) + + +if __name__ == "__main__": + main() diff --git a/docs/make.bat b/docs/make.bat deleted file mode 100644 index 6247f7e..0000000 --- a/docs/make.bat +++ /dev/null @@ -1,35 +0,0 @@ -@ECHO OFF - -pushd %~dp0 - -REM Command file for Sphinx documentation - -if "%SPHINXBUILD%" == "" ( - set SPHINXBUILD=sphinx-build -) -set SOURCEDIR=source -set BUILDDIR=build - -if "%1" == "" goto help - -%SPHINXBUILD% >NUL 2>NUL -if errorlevel 9009 ( - echo. - echo.The 'sphinx-build' command was not found. Make sure you have Sphinx - echo.installed, then set the SPHINXBUILD environment variable to point - echo.to the full path of the 'sphinx-build' executable. Alternatively you - echo.may add the Sphinx directory to PATH. - echo. - echo.If you don't have Sphinx installed, grab it from - echo.http://sphinx-doc.org/ - exit /b 1 -) - -%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% -goto end - -:help -%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% - -:end -popd diff --git a/docs/source/_static/custom.css b/docs/source/_static/custom.css new file mode 100644 index 0000000..62fa184 --- /dev/null +++ b/docs/source/_static/custom.css @@ -0,0 +1,11 @@ +/* Match the larger base font of the original pysampling docs. The current + sphinx-book-theme/pydata-sphinx-theme tightened its default type scale; this + bumps it back up. We override the theme's own base-font variable (the + intended knob) so every rem-derived size scales with it. */ +:root { + --pst-font-size-base: 18px; +} + +html { + font-size: 18px; +} diff --git a/docs/source/conf.py b/docs/source/conf.py index ed48878..2a12b6e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,65 +1,33 @@ -# Config file for the Sphinx documentation builder. -# -# This file only contains a selection of the most common options. For a full -# list see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html +"""Sphinx configuration for the pysampling documentation. -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -# -# import os -# import sys -# sys.path.insert(0, os.path.abspath('.')) +Notebooks are executed out-of-band by the docs runner (jupyter-cache); Sphinx +itself never executes them (``nbsphinx_execute = 'never'``) — it only renders the +already-hydrated ``.ipynb`` files. +""" import os import sys -sys.path.insert(0, os.path.abspath('../..')) -from pysampling.version import __version__ - -# -- Project information ----------------------------------------------------- - -project = 'pysampling' -copyright = '2021, Julian Blank' -author = 'Julian Blank' - -# The full version, including alpha/beta/rc tags -release = __version__ -# -- General configuration --------------------------------------------------- +sys.path.insert(0, os.path.abspath("../../src")) -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. -extensions = [ - 'nbsphinx' -] +import pysampling # noqa: E402 -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] +project = "pysampling" +copyright = "2026, Julian Blank" +author = "Julian Blank" +release = pysampling.__version__ -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ['**.ipynb_checkpoints'] +extensions = ["nbsphinx"] -# -- Options for HTML output ------------------------------------------------- - - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] +exclude_patterns = ["build", "**.ipynb_checkpoints"] html_theme = "sphinx_book_theme" html_logo = "_static/pysampling.png" html_title = "pysampling" +html_static_path = ["_static"] +html_css_files = ["custom.css"] html_copy_source = False html_sourcelink_suffix = "" -html_last_updated_fmt = "" - -# -- nbsphinx_allow_errors --------------------------------------------------- -nbsphinx_allow_errors = True +# Notebooks are pre-executed by the docs runner; Sphinx must never re-execute them. +nbsphinx_execute = "never" diff --git a/docs/source/index.ipynb b/docs/source/index.ipynb deleted file mode 100644 index 84248cb..0000000 --- a/docs/source/index.ipynb +++ /dev/null @@ -1,377 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# pysampling" - ] - }, - { - "cell_type": "raw", - "metadata": { - "raw_mimetype": "text/restructuredtext" - }, - "source": [ - "\n", - "\n", - "\n", - "\n", - "|python| |license|\n", - "\n", - "\n", - "\n", - ".. |python| image:: https://img.shields.io/badge/python-3.6-blue.svg\n", - " :alt: python 3.6\n", - "\n", - ".. |license| image:: https://img.shields.io/badge/license-apache-orange.svg\n", - " :alt: license apache\n", - " :target: https://www.apache.org/licenses/LICENSE-2.0\n", - " \n", - " \n", - "https://github.com/anyoptimization/pysampling\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Installation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The framework is available at the PyPi Repository:" - ] - }, - { - "cell_type": "raw", - "metadata": { - "raw_mimetype": "text/restructuredtext" - }, - "source": [ - ".. code-block:: bash\n", - "\n", - " pip install -U pysampling" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Usage" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The method to be used for sampling using different algorithm must be import from pysampling.sample. Here, we use Latin Hypercube Sampling to generate 50 points in 2 dimensions. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from pysampling.sample import sample\n", - "\n", - "X = sample(\"lhs\", 50, 2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then, we recommend using matpotlib or other visualization libraries to have a look at the results:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 248, - "width": 372 - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.scatter(X[:, 0], X[:, 1], s=30, facecolors='none', edgecolors='r')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Features" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So far our library provides the following implementations:\n", - " \n", - "- Random ('random')\n", - "- Latin Hypercube Sampling ('lhs')\n", - "- Sobol ('sobol')\n", - "- Halton ('halton')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The initialization of each of those will be shown in the following.\n", - "Let us first define a method that helps us to visualize them in a 2d space." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "def show(X):\n", - " plt.scatter(X[:, 0], X[:, 1], s=30, facecolors='none', edgecolors='r')\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Random ('random')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 248, - "width": 372 - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "X = sample(\"random\", 50, 2, seed=1)\n", - "show(X)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Latin Hypercube Sampling ('lhs')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 248, - "width": 372 - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "X = sample(\"lhs\", 50, 2, seed=1)\n", - "show(X)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Sobol ('sobol')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 248, - "width": 372 - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "X = sample(\"sobol\", 84, 2)\n", - "show(X)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 248, - "width": 372 - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "X = sample(\"sobol\", 84, 2, n_skip=100, n_leap=10)\n", - "show(X)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Halton ('halton')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 248, - "width": 372 - }, - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "X = sample(\"halton\", 100, 2)\n", - "show(X)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Contact" - ] - }, - { - "cell_type": "raw", - "metadata": { - "raw_mimetype": "text/restructuredtext" - }, - "source": [ - ".. |blankjul| raw:: html\n", - "\n", - " My personal homepage\n", - "\n", - "\n", - "|blankjul|\n", - "\n", - "Feel free to contact me if you have any question:\n", - "\n", - "::\n", - "\n", - " Julian Blank (blankjul [at] egr.msu.edu)\n", - " Michigan State University\n", - " Computational Optimization and Innovation Laboratory (COIN)\n", - " East Lansing, MI 48824, USA\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/docs/source/index.md b/docs/source/index.md new file mode 100644 index 0000000..e28a52b --- /dev/null +++ b/docs/source/index.md @@ -0,0 +1,132 @@ +--- +jupytext: + formats: ipynb,md:myst + text_representation: + extension: .md + format_name: myst +kernelspec: + display_name: Python 3 + name: python3 +--- + +# pysampling + +![python](https://img.shields.io/badge/python-3.10+-blue.svg) +![license](https://img.shields.io/badge/license-apache-orange.svg) + + + +## Installation + +The framework is available at the PyPi Repository: + +```bash +pip install -U pysampling +``` + +## Usage + +The method to be used for sampling using a different algorithm must be imported +from `pysampling.sample`. Here, we use Latin Hypercube Sampling to generate 50 +points in 2 dimensions. + +```{code-cell} ipython3 +from pysampling.sample import sample + +X = sample("lhs", 50, 2) +``` + +Then, we recommend using matplotlib or other visualization libraries to have a +look at the results: + +```{code-cell} ipython3 +import matplotlib.pyplot as plt + +plt.scatter(X[:, 0], X[:, 1], s=30, facecolors="none", edgecolors="r") +plt.show() +``` + +## Features + +So far our library provides the following implementations: + +- Random (`'random'`) +- Latin Hypercube Sampling (`'lhs'`) +- Sobol (`'sobol'`) +- Halton (`'halton'`) + +The initialization of each of those will be shown in the following. Let us first +define a method that helps us to visualize them in a 2d space. + +```{code-cell} ipython3 +import matplotlib.pyplot as plt + + +def show(X): + plt.figure(figsize=(5, 5)) + plt.scatter(X[:, 0], X[:, 1], s=30, facecolors="none", edgecolors="r") + plt.xlim(0, 1) + plt.ylim(0, 1) + plt.gca().set_aspect("equal") + plt.show() +``` + +### Random (`'random'`) + +```{code-cell} ipython3 +X = sample("random", 50, 2, seed=1) +show(X) +``` + +### Latin Hypercube Sampling (`'lhs'`) + +```{code-cell} ipython3 +X = sample("lhs", 50, 2, seed=1) +show(X) +``` + +### Sobol (`'sobol'`) + +```{code-cell} ipython3 +X = sample("sobol", 84, 2) +show(X) +``` + +The Sobol sequence can be customized — for example, skipping the first points +and leaping over points in the sequence: + +```{code-cell} ipython3 +X = sample("sobol", 84, 2, n_skip=100, n_leap=10) +show(X) +``` + +### Halton (`'halton'`) + +```{code-cell} ipython3 +X = sample("halton", 100, 2) +show(X) +``` + +## Comparing uniformity + +A more uniform spread has a lower discrepancy. We can quantify it with the +measures in `pysampling.measures` — here the centered L2 discrepancy of 100 +points in 2D for each algorithm (lower is better): + +```{code-cell} ipython3 +from pysampling.measures import centered_l2_discrepancy + +for name in ["random", "lhs", "halton", "sobol"]: + Y = sample(name, 100, 2, seed=1) + print(f"{name:8s} {centered_l2_discrepancy(Y):.5f}") +``` + +## Contact + +Feel free to contact me if you have any question: + +``` +Julian Blank (blankjul [at] outlook.com) +Michigan State University +Computational Optimization and Innovation Laboratory (COIN) +``` diff --git a/docs/source/jupytext.toml b/docs/source/jupytext.toml new file mode 100644 index 0000000..73d49ba --- /dev/null +++ b/docs/source/jupytext.toml @@ -0,0 +1 @@ +formats = "ipynb,md:myst" diff --git a/examples/plot_sampling.py b/examples/plot_sampling.py new file mode 100644 index 0000000..bc3524b --- /dev/null +++ b/examples/plot_sampling.py @@ -0,0 +1,24 @@ +"""Visualize a sampled point set. + +Run with the optional plotting dependency installed:: + + pip install pysampling[plot] + python examples/plot_sampling.py +""" + +from __future__ import annotations + +import matplotlib.pyplot as plt + +from pysampling.sample import sample + + +def main() -> None: + X = sample("sobol", 84, 2, n_skip=100, n_leap=10) + plt.scatter(X[:, 0], X[:, 1], s=30, facecolors="none", edgecolors="r") + plt.title("pysampling — sobol, 84 points in 2D") + plt.show() + + +if __name__ == "__main__": + main() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..40c41ac --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,95 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "pysampling" +description = "Sampling methods for design of experiments in Python (random, LHS, Halton, Sobol)." +authors = [{ name = "Julian Blank", email = "blankjul@outlook.com" }] +readme = "README.md" +license = "Apache-2.0" +requires-python = ">=3.10" +keywords = ["sampling", "design of experiments", "latin hypercube", "sobol", "halton", "optimization"] +dynamic = ["version"] +dependencies = [ + "numpy>=1.23", +] +classifiers = [ + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Mathematics", +] + +[project.optional-dependencies] +plot = ["matplotlib>=3.5"] + +[project.urls] +Homepage = "https://anyoptimization.com/projects/pysampling" +Source = "https://github.com/anyoptimization/pysampling" + +# Single source of truth for the version: src/pysampling/__init__.py::__version__. +[tool.hatch.version] +path = "src/pysampling/__init__.py" + +[tool.hatch.build.targets.wheel] +packages = ["src/pysampling"] + +# PEP 735 dependency group — dev tooling, NOT a shipped extra. +[dependency-groups] +dev = [ + "pytest>=8", + "pytest-xdist>=3", # `pyclawd test fast` runs under `-n auto` + "ruff>=0.6", + "mypy>=1.10", +] +# Documentation toolchain — installed into the project env (`pip install -e . --group docs`) +# and driven by `pyclawd docs build` → `python docs/cli.py`. Kept out of the shipped +# package (PEP 735 group, not an extra). +docs = [ + # Sphinx + rendering + "sphinx>=7,<9", + "nbsphinx>=0.9,<1.0", + "sphinx-book-theme>=1.1,<2.0", + "sphinx-copybutton", + "numpydoc", + # Notebook compile + execute + cache + "jupytext", + "jupyter-cache", + "nbclient", + "nbconvert", + "nbformat", + "ipykernel", + # Needed to execute the example notebooks + "matplotlib>=3.5", +] + +# --------------------------------------------------------------------------- # +# Code-quality toolchain (run via `pyclawd lint/format/typecheck/check`). +# --------------------------------------------------------------------------- # + +[tool.ruff] +line-length = 100 +target-version = "py310" +src = ["src", "tests"] +# docs/ is a self-contained builder package with its own pyproject and toolchain. +extend-exclude = ["docs"] + +[tool.ruff.lint] +# pyflakes (F), pycodestyle (E), isort (I), bugbear (B), pyupgrade (UP), +# flake8-simplify (SIM), comprehensions (C4). +select = ["E", "F", "I", "B", "UP", "SIM", "C4"] + +[tool.mypy] +python_version = "3.10" +files = ["src"] +ignore_missing_imports = true +warn_unused_configs = true +check_untyped_defs = true + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "-q" diff --git a/pysampling/usage.py b/pysampling/usage.py deleted file mode 100644 index 7bf0359..0000000 --- a/pysampling/usage.py +++ /dev/null @@ -1,9 +0,0 @@ -import matplotlib.pyplot as plt - -from pysampling.sample import sample - -X = sample("sobol", 84, 2, n_skip=100, n_leap=10) - -plt.scatter(X[:, 0], X[:, 1]) -plt.show() - diff --git a/pysampling/version.py b/pysampling/version.py deleted file mode 100644 index b3f4756..0000000 --- a/pysampling/version.py +++ /dev/null @@ -1 +0,0 @@ -__version__ = "0.1.2" diff --git a/setup.py b/setup.py deleted file mode 100644 index 2a6947f..0000000 --- a/setup.py +++ /dev/null @@ -1,59 +0,0 @@ -from setuptools import setup - -from pysampling.version import __version__ - -# --------------------------------------------------------------------------------------------------------- -# GENERAL -# --------------------------------------------------------------------------------------------------------- - - -__name__ = "pysampling" -__author__ = "Julian Blank" -__url__ = "https://www.egr.msu.edu/coinlab/blankjul/pysampling/" - -data = dict( - name=__name__, - version=__version__, - author=__author__, - url=__url__, - python_requires='>=3.6', - author_email="blankjul@egr.msu.edu", - description="Multi-Objective Optimization in Python", - license='Apache License 2.0', - keywords="optimization", - install_requires=['numpy>=1.15'], - include_package_data=True, - platforms='any', - classifiers=[ - 'Intended Audience :: Developers', - 'Intended Audience :: Science/Research', - 'Operating System :: OS Independent', - 'License :: OSI Approved :: Apache Software License', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - 'Topic :: Scientific/Engineering', - 'Topic :: Scientific/Engineering :: Artificial Intelligence', - 'Topic :: Scientific/Engineering :: Mathematics' - ] -) - - -# --------------------------------------------------------------------------------------------------------- -# OTHER METADATA -# --------------------------------------------------------------------------------------------------------- - -def readme(): - with open('README.rst') as f: - return f.read() - - -data['long_description'] = readme() -data['packages'] = ['pysampling', 'pysampling.algorithms', 'pysampling.resources'] - -# --------------------------------------------------------------------------------------------------------- -# SETUP -# --------------------------------------------------------------------------------------------------------- - -setup(**data) diff --git a/src/pysampling/__init__.py b/src/pysampling/__init__.py new file mode 100644 index 0000000..fce6cd8 --- /dev/null +++ b/src/pysampling/__init__.py @@ -0,0 +1,14 @@ +"""pysampling — sampling methods for design of experiments in Python. + +Generate well-spread point sets in the unit hypercube using random, Latin +Hypercube, Halton, and Sobol sampling, and assess their quality with a suite of +uniformity/discrepancy measures. +""" + +from __future__ import annotations + +from pysampling.sample import sample + +__version__ = "0.1.2" + +__all__ = ["sample", "__version__"] diff --git a/pysampling/__init__.py b/src/pysampling/algorithms/__init__.py similarity index 100% rename from pysampling/__init__.py rename to src/pysampling/algorithms/__init__.py diff --git a/pysampling/algorithms/halton.py b/src/pysampling/algorithms/halton.py similarity index 99% rename from pysampling/algorithms/halton.py rename to src/pysampling/algorithms/halton.py index 19b281d..2fc2c86 100644 --- a/pysampling/algorithms/halton.py +++ b/src/pysampling/algorithms/halton.py @@ -19,7 +19,6 @@ def halton_sequence(n, b): class HaltonSampling(Sampling): - def _sample(self, n_points, n_dim): bases = calc_primes_until(500)[:n_dim] X = np.column_stack([halton_sequence(n_points, b) for b in bases]) diff --git a/pysampling/algorithms/lhs.py b/src/pysampling/algorithms/lhs.py similarity index 72% rename from pysampling/algorithms/lhs.py rename to src/pysampling/algorithms/lhs.py index a0b0ff7..2d60ce7 100644 --- a/pysampling/algorithms/lhs.py +++ b/src/pysampling/algorithms/lhs.py @@ -1,29 +1,22 @@ import numpy as np -from pysampling.measures import minimum_distance, correlation +from pysampling.measures import correlation, minimum_distance from pysampling.sampling import Sampling def sample(n_points, n_dim, smooth=True): X = np.random.random(size=(n_points, n_dim)) - val = X.argsort(axis=0) + 1 + ranks = X.argsort(axis=0) + 1 - if smooth: - val = val - np.random.random(val.shape) - else: - val = val - 0.5 - val /= n_points + val = ranks - np.random.random(ranks.shape) if smooth else ranks - 0.5 + val = val / n_points return val class LatinHypercubeSampling(Sampling): - - def __init__(self, - criterion="maxmin", - iterations=1000, - **kwargs): + def __init__(self, criterion="maxmin", iterations=1000, **kwargs): super().__init__(**kwargs) self.criterion = criterion @@ -43,8 +36,7 @@ def _sample(self, n_points, n_dim): f = self.fun_obj(X) # for each iteration try to improve it - for i in range(self.iterations): - + for _ in range(self.iterations): # random _X = sample(n_points, n_dim) _f = self.fun_obj(_X) @@ -54,6 +46,3 @@ def _sample(self, n_points, n_dim): X, f = _X, _f return X - - - diff --git a/pysampling/algorithms/random.py b/src/pysampling/algorithms/random.py similarity index 99% rename from pysampling/algorithms/random.py rename to src/pysampling/algorithms/random.py index 6fbd8e7..c750972 100644 --- a/pysampling/algorithms/random.py +++ b/src/pysampling/algorithms/random.py @@ -4,6 +4,5 @@ class RandomSampling(Sampling): - def _sample(self, n_points, n_dim): return np.random.random((n_points, n_dim)) diff --git a/pysampling/algorithms/sobol.py b/src/pysampling/algorithms/sobol.py similarity index 74% rename from pysampling/algorithms/sobol.py rename to src/pysampling/algorithms/sobol.py index 66bbacf..d396969 100644 --- a/pysampling/algorithms/sobol.py +++ b/src/pysampling/algorithms/sobol.py @@ -1,18 +1,13 @@ -import numpy as np - import re +import numpy as np + from pysampling.sampling import Sampling from pysampling.util import path_to_resource class SobolSampling(Sampling): - - def __init__(self, - n_skip=None, - n_leap=0, - setup="joekuo", - **kwargs): + def __init__(self, n_skip=None, n_leap=0, setup="joekuo", **kwargs): super().__init__(**kwargs) @@ -45,15 +40,15 @@ def __init__(self, def _sample(self, n_points, n_dim): # find out how long the sequence needs to be - skip or leap included - I = np.arange(0, n_points) * (self.n_leap + 1) + idx = np.arange(0, n_points) * (self.n_leap + 1) if self.n_skip == -1: - I += n_points + idx += n_points else: - I += self.n_skip - n_sequence = np.max(I) + 1 + idx += self.n_skip + n_sequence = np.max(idx) + 1 # contains all the values of the sequences as integer - _X = np.zeros((n_sequence, n_dim), dtype=np.int) + _X = np.zeros((n_sequence, n_dim), dtype=np.int64) # number of bits which will be necessary for this sequence L = int(np.ceil(np.log2(n_sequence))) @@ -62,33 +57,30 @@ def _sample(self, n_points, n_dim): C = [highest_bit(i) for i in range(0, n_sequence)] for j in range(n_dim): - if j == 0: - V = np.concatenate((np.array([0]), 2 ** np.arange(self.max_bits-1, -1, -1))) + V = np.concatenate((np.array([0]), 2 ** np.arange(self.max_bits - 1, -1, -1))) else: - s, a, m = self.setup[j]["s"], self.setup[j]["a"], self.setup[j]["m"] - V = np.zeros(L + 1, dtype=np.int) + V = np.zeros(L + 1, dtype=np.int64) - if L <= s: + if s >= L: for k in range(1, L + 1): V[k] = m[k - 1] << (self.max_bits - k) else: - for k in range(1, s + 1): V[k] = m[k - 1] << (self.max_bits - k) for i in range(s + 1, L + 1): V[i] = V[i - s] ^ int(V[i - s] >> s) for k in range(1, s): - V[i] ^= (((a >> (s - 1 - k)) & 1) * V[i - k]) + V[i] ^= ((a >> (s - 1 - k)) & 1) * V[i - k] for i in range(1, n_sequence): _X[i, j] = _X[i - 1, j] ^ V[C[i - 1]] - X = (_X / 2 ** self.max_bits)[I] + X = (_X / 2**self.max_bits)[idx] return X @@ -101,20 +93,16 @@ def highest_bit(i): def parse_file(path_to_file): - setup = [{}] + setup: list[dict] = [{}] with open(path_to_file) as f: content = f.read().splitlines()[1:] for line in content: - entries = [int(e) for e in re.split("\s+|\t", line.strip())] - - setup.append({ - 'd': entries[0], - 's': entries[1], - 'a': entries[2], - 'm': np.array(entries[3:]) + entries = [int(e) for e in re.split(r"\s+|\t", line.strip())] - }) + setup.append( + {"d": entries[0], "s": entries[1], "a": entries[2], "m": np.array(entries[3:])} + ) return setup diff --git a/pysampling/measures.py b/src/pysampling/measures.py similarity index 59% rename from pysampling/measures.py rename to src/pysampling/measures.py index b010a9d..9703fb4 100644 --- a/pysampling/measures.py +++ b/src/pysampling/measures.py @@ -6,7 +6,7 @@ def minimum_distance(X): D = cdist(X, X) np.fill_diagonal(D, np.inf) - return - np.min(D) + return -np.min(D) def correlation(X): @@ -14,9 +14,9 @@ def correlation(X): return np.sum(np.tril(M, -1) ** 2) -# --------------------------------------------------------------------------------------------------------- +# --------------------------------------------------------------------------- # # Discrepancy -# --------------------------------------------------------------------------------------------------------- +# --------------------------------------------------------------------------- # # # Reimplemented from https://rdrr.io/cran/DiceDesign/man/discrepancyCriteria.html @@ -25,28 +25,40 @@ def centered_l2_discrepancy(X): n_points, n_dim = X.shape cX = np.abs(X - 0.5) - s1 = ((1 + 0.5 * cX - 0.5 * cX ** 2).prod(axis=1)).sum() - s2 = ((1 + 0.5 * cX[:, None] + 0.5 * cX[None, :] - 0.5 * np.abs(X[:, None] - X[None, :])).prod(axis=2)).sum() + s1 = ((1 + 0.5 * cX - 0.5 * cX**2).prod(axis=1)).sum() + s2 = ( + (1 + 0.5 * cX[:, None] + 0.5 * cX[None, :] - 0.5 * np.abs(X[:, None] - X[None, :])).prod( + axis=2 + ) + ).sum() - return np.sqrt(((13 / 12) ** n_dim) - ((2 / n_points) * s1) + ((1 / n_points ** 2) * s2)) + return np.sqrt(((13 / 12) ** n_dim) - ((2 / n_points) * s1) + ((1 / n_points**2) * s2)) def l2_discrepancy(X): n_points, n_dim = X.shape s1 = np.sum(np.prod(X * (1 - X), axis=1)) - s2 = np.sum(np.prod((1 - np.maximum(X[:, None], X[None, :])) * np.minimum(X[:, None], X[None, :]), axis=2)) - return np.sqrt(12 ** (-n_dim) - (((2 ** (1 - n_dim)) / n_points) * s1) + ((1 / n_points ** 2) * s2)) + s2 = np.sum( + np.prod( + (1 - np.maximum(X[:, None], X[None, :])) * np.minimum(X[:, None], X[None, :]), axis=2 + ) + ) + return np.sqrt( + 12 ** (-n_dim) - (((2 ** (1 - n_dim)) / n_points) * s1) + ((1 / n_points**2) * s2) + ) def l2_star_discrepancy(X): n_points, n_dim = X.shape # all off diagonal elements - t1 = (1 - np.maximum(X[:, None], X[None, :])).prod(axis=2) / (n_points ** 2) + t1 = (1 - np.maximum(X[:, None], X[None, :])).prod(axis=2) / (n_points**2) t1 = t1 * (1 - np.eye(n_points)) # all elements on the diagonal - t2 = (1 - X).prod(axis=1) / (n_points ** 2) - ((2 ** (1 - n_dim)) / n_points) * (1 - X ** 2).prod(axis=1) + t2 = (1 - X).prod(axis=1) / (n_points**2) - ((2 ** (1 - n_dim)) / n_points) * (1 - X**2).prod( + axis=1 + ) return np.sqrt(3 ** (-n_dim) + t1.sum() + t2.sum()) @@ -54,17 +66,19 @@ def l2_star_discrepancy(X): def modified_l2_discrepancy(X): n_points, n_dim = X.shape - s1 = (3 - X ** 2).prod(axis=1).sum() + s1 = (3 - X**2).prod(axis=1).sum() s2 = (2 - np.maximum(X[:, None], X[None, :])).prod(axis=2).sum() - return np.sqrt(((4 / 3) ** n_dim) - (((2 ** (1 - n_dim)) / n_points) * s1) + ((1 / n_points ** 2) * s2)) + return np.sqrt( + ((4 / 3) ** n_dim) - (((2 ** (1 - n_dim)) / n_points) * s1) + ((1 / n_points**2) * s2) + ) def symmetric_l2_discrepancy(X): n_points, n_dim = X.shape - s1 = (1 + (2 * X) - 2 * X ** 2).prod(axis=1).sum() + s1 = (1 + (2 * X) - 2 * X**2).prod(axis=1).sum() s2 = (1 - np.abs(X[:, None] - X[None, :])).prod(axis=2).sum() - return np.sqrt(((4 / 3) ** n_dim) - ((2 / n_points) * s1) + ((2 ** n_dim / n_points ** 2) * s2)) + return np.sqrt(((4 / 3) ** n_dim) - ((2 / n_points) * s1) + ((2**n_dim / n_points**2) * s2)) def wrap_around_l2_discrepancy(X): @@ -73,4 +87,4 @@ def wrap_around_l2_discrepancy(X): val = np.abs(X[:, None] - X[None, :]) s = (1.5 - val * (1 - val)).prod(axis=2).sum() - return np.sqrt((-((4 / 3) ** n_dim) + ((1 / n_points ** 2) * s))) + return np.sqrt(-((4 / 3) ** n_dim) + ((1 / n_points**2) * s)) diff --git a/pysampling/algorithms/__init__.py b/src/pysampling/py.typed similarity index 100% rename from pysampling/algorithms/__init__.py rename to src/pysampling/py.typed diff --git a/pysampling/resources/sobol_burkardt.dat b/src/pysampling/resources/sobol_burkardt.dat similarity index 100% rename from pysampling/resources/sobol_burkardt.dat rename to src/pysampling/resources/sobol_burkardt.dat diff --git a/pysampling/resources/sobol_joekuo.dat b/src/pysampling/resources/sobol_joekuo.dat similarity index 100% rename from pysampling/resources/sobol_joekuo.dat rename to src/pysampling/resources/sobol_joekuo.dat diff --git a/pysampling/resources/sobol_matlab.dat b/src/pysampling/resources/sobol_matlab.dat similarity index 100% rename from pysampling/resources/sobol_matlab.dat rename to src/pysampling/resources/sobol_matlab.dat diff --git a/pysampling/sample.py b/src/pysampling/sample.py similarity index 75% rename from pysampling/sample.py rename to src/pysampling/sample.py index f2f3f2f..9828f7b 100644 --- a/pysampling/sample.py +++ b/src/pysampling/sample.py @@ -2,10 +2,13 @@ from pysampling.algorithms.lhs import LatinHypercubeSampling from pysampling.algorithms.random import RandomSampling from pysampling.algorithms.sobol import SobolSampling +from pysampling.sampling import Sampling def sample(algorithm, n_points, n_dim, *args, **kwargs): + _obj: Sampling + if algorithm == "random": _obj = RandomSampling(*args, **kwargs) @@ -18,6 +21,9 @@ def sample(algorithm, n_points, n_dim, *args, **kwargs): elif algorithm == "sobol": _obj = SobolSampling(*args, **kwargs) else: - raise Exception("Unknown method for random sampling.") + raise ValueError( + f"Unknown sampling algorithm: {algorithm!r}. " + "Options: ['random', 'lhs', 'halton', 'sobol']." + ) return _obj.sample(n_points, n_dim) diff --git a/pysampling/sampling.py b/src/pysampling/sampling.py similarity index 97% rename from pysampling/sampling.py rename to src/pysampling/sampling.py index 50a4632..73834e4 100644 --- a/pysampling/sampling.py +++ b/src/pysampling/sampling.py @@ -1,5 +1,6 @@ import numpy as np + class Sampling: """ The abstract sampling class that builds the frame for each implementation of sampling methods. @@ -17,4 +18,4 @@ def sample(self, n_points, n_dim): return self._sample(n_points, n_dim) def _sample(self, n_points, n_dim, *args): - pass \ No newline at end of file + pass diff --git a/pysampling/util.py b/src/pysampling/util.py similarity index 67% rename from pysampling/util.py rename to src/pysampling/util.py index a558d84..bdc5903 100644 --- a/pysampling/util.py +++ b/src/pysampling/util.py @@ -8,6 +8,11 @@ def path_to_resource(fname): def cdist(A, B, _type="repeat"): + """Pairwise Euclidean distance matrix between rows of ``A`` and ``B``. + + The ``_type`` argument selects the implementation; all return the same + ``(A.shape[0], B.shape[0])`` distance matrix. + """ if _type == "repeat": u = np.repeat(A, B.shape[0], axis=0) v = np.tile(B, (A.shape[0], 1)) @@ -15,13 +20,13 @@ def cdist(A, B, _type="repeat"): D = np.sqrt(np.sum((u - v) ** 2, axis=1)) return np.reshape(D, (A.shape[0], B.shape[0])) - elif _type == "repeat": - _A = np.sum(A ** 2, axis=1)[None, ...] - _B = np.sum(B ** 2, axis=1)[..., None] + elif _type == "matmul": + _A = np.sum(A**2, axis=1)[None, ...] + _B = np.sum(B**2, axis=1)[..., None] val = _A + _B - 2.0 * A @ B.T return np.sqrt(val) - elif _type == "repeat": + elif _type == "broadcast": _A = A[:, None, ...] _B = B[None, ...] return np.sqrt(np.sum((_A - _B) ** 2, axis=2)) @@ -29,17 +34,15 @@ def cdist(A, B, _type="repeat"): else: raise Exception("Unknown type for cdist!") - return M - def calc_primes_until(n): size = n // 2 sieve = [1] * size - limit = int(n ** 0.5) + limit = int(n**0.5) for i in range(1, limit): if sieve[i]: val = 2 * i + 1 tmp = ((size - 1) - i) // val - sieve[i + val::val] = [0] * tmp + sieve[i + val :: val] = [0] * tmp return [2] + [i * 2 + 1 for i, v in enumerate(sieve) if v and i > 0] diff --git a/tests/test_discrepancy.py b/tests/test_discrepancy.py index a491263..58e6d43 100644 --- a/tests/test_discrepancy.py +++ b/tests/test_discrepancy.py @@ -1,51 +1,21 @@ -import unittest - import numpy as np - -from pysampling.measures import centered_l2_discrepancy, l2_discrepancy, l2_star_discrepancy, modified_l2_discrepancy, \ - symmetric_l2_discrepancy, wrap_around_l2_discrepancy +import pytest + +from pysampling.measures import ( + centered_l2_discrepancy, + l2_discrepancy, + l2_star_discrepancy, + modified_l2_discrepancy, + symmetric_l2_discrepancy, + wrap_around_l2_discrepancy, +) from tests.util import path_to_resources -CORRECT = { - "centered_l2_discrepancy": 0.3325753, - "l2_discrepancy": 0.01605584, - "l2_star_discrepancy": 0.1394512, - "modified_l2_discrepancy": 0.4616604, - "symmetric_l2_discrepancy": 0.945297, - "wrap_around_l2_discrepancy": 0.2215735, -} - - -class DiscrepancyTest(unittest.TestCase): - - def test_centered_l2_discrepancy(self): - X = np.loadtxt(path_to_resources("discrepancy.x")) - self.assertAlmostEqual(centered_l2_discrepancy(X), CORRECT["centered_l2_discrepancy"]) - - def test_l2_discrepancy(self): - X = np.loadtxt(path_to_resources("discrepancy.x")) - self.assertAlmostEqual(l2_discrepancy(X), CORRECT["l2_discrepancy"]) - - def test_l2_star_discrepancy(self): - X = np.loadtxt(path_to_resources("discrepancy.x")) - self.assertAlmostEqual(l2_star_discrepancy(X), CORRECT["l2_star_discrepancy"]) - - def test_modified_l2_discrepancy(self): - X = np.loadtxt(path_to_resources("discrepancy.x")) - self.assertAlmostEqual(modified_l2_discrepancy(X), CORRECT["modified_l2_discrepancy"]) - - def test_symmetric_l2_discrepancy(self): - X = np.loadtxt(path_to_resources("discrepancy.x")) - self.assertAlmostEqual(symmetric_l2_discrepancy(X), CORRECT["symmetric_l2_discrepancy"]) - - def test_wrap_around_l2_discrepancy(self): - X = np.loadtxt(path_to_resources("discrepancy.x")) - self.assertAlmostEqual(wrap_around_l2_discrepancy(X), CORRECT["wrap_around_l2_discrepancy"]) - - -# --------------------------------------------------------------------------------------------------------- -# LOOPED -# --------------------------------------------------------------------------------------------------------- +# --------------------------------------------------------------------------- # +# LOOPED REFERENCE IMPLEMENTATIONS +# --------------------------------------------------------------------------- # +# Straightforward (slow) implementations kept as ground truth for the vectorized +# measures in pysampling.measures. def wrap_around_l2_discrepancy_loop(X): @@ -54,11 +24,10 @@ def wrap_around_l2_discrepancy_loop(X): for i in range(n): for k in range(n): - p = np.prod((1.5 - ((abs(X[i,] - X[k,])) * (1 - abs(X[i,] - X[k,]))))) - + p = np.prod(1.5 - ((abs(X[i,] - X[k,])) * (1 - abs(X[i,] - X[k,])))) s1 += p - return np.sqrt((-((4 / 3) ** m) + ((1 / n ** 2) * s1))) + return np.sqrt(-((4 / 3) ** m) + ((1 / n**2) * s1)) def symmetric_l2_discrepancy_loop(X): @@ -67,14 +36,14 @@ def symmetric_l2_discrepancy_loop(X): s2 = 0 for i in range(n): - p = np.prod((1 + (2 * X[i,]) - (2 * X[i,] * X[i,]))) + p = np.prod(1 + (2 * X[i,]) - (2 * X[i,] * X[i,])) s1 += p for k in range(n): - q = np.prod((1 - abs(X[i,] - X[k,]))) + q = np.prod(1 - abs(X[i,] - X[k,])) s2 += q - return np.sqrt(((4 / 3) ** m) - ((2 / n) * s1) + ((2 ** m / n ** 2) * s2)) + return np.sqrt(((4 / 3) ** m) - ((2 / n) * s1) + ((2**m / n**2) * s2)) def modified_l2_discrepancy_loop(X): @@ -83,7 +52,7 @@ def modified_l2_discrepancy_loop(X): s2 = 0 for i in range(n): - p = np.prod((3 - (X[i,] * X[i,]))) + p = np.prod(3 - (X[i,] * X[i,])) s1 += p for k in range(n): @@ -93,7 +62,7 @@ def modified_l2_discrepancy_loop(X): s2 += q - return np.sqrt(((4 / 3) ** m) - (((2 ** (1 - m)) / n) * s1) + ((1 / n ** 2) * s2)) + return np.sqrt(((4 / 3) ** m) - (((2 ** (1 - m)) / n) * s1) + ((1 / n**2) * s2)) def l2_star_discrepancy_loop(X): @@ -103,19 +72,17 @@ def l2_star_discrepancy_loop(X): for j in range(n): for i in range(n): if i != j: - t = [] - for l in range(m): - t.append(1 - max(X[i, l], X[j, l])) - t = np.prod(np.array(t)) / (n ** 2) + for d in range(m): + t.append(1 - max(X[i, d], X[j, d])) + t = np.prod(np.array(t)) / (n**2) else: - t1 = 1 - X[i,] t1 = np.prod(t1) t2 = 1 - X[i,] ** 2 t2 = np.prod(t2) - t = t1 / (n ** 2) - ((2 ** (1 - m)) / n) * t2 + t = t1 / (n**2) - ((2 ** (1 - m)) / n) * t2 dL2 += t @@ -131,14 +98,13 @@ def l2_discrepancy_loop(X): s1 += np.prod(X[i] * (1 - X[i])) for k in range(n): - q = 1 for j in range(m): q = q * (1 - max(X[i, j], X[k, j])) * min(X[i, j], X[k, j]) s2 += q - return np.sqrt(12 ** (-m) - (((2 ** (1 - m)) / n) * s1) + ((1 / n ** 2) * s2)) + return np.sqrt(12 ** (-m) - (((2 ** (1 - m)) / n) * s1) + ((1 / n**2) * s2)) def centered_l2_discrepancy_loop(X): @@ -146,19 +112,45 @@ def centered_l2_discrepancy_loop(X): s1 = 0 for i in range(n): - p = np.prod((1 + 0.5 * abs(X[i,] - 0.5) - 0.5 * ((abs(X[i,] - 0.5)) ** 2))) + p = np.prod(1 + 0.5 * abs(X[i,] - 0.5) - 0.5 * ((abs(X[i,] - 0.5)) ** 2)) s1 = s1 + p s2 = 0 for i in range(n): for k in range(n): - q = np.prod((1 + 0.5 * abs(X[i,] - 0.5) + 0.5 * abs(X[k,] - 0.5) - 0.5 * abs(X[i,] - X[k,]))) + q = np.prod( + 1 + 0.5 * abs(X[i,] - 0.5) + 0.5 * abs(X[k,] - 0.5) - 0.5 * abs(X[i,] - X[k,]) + ) s2 = s2 + q - val = np.sqrt(((13 / 12) ** m) - ((2 / n) * s1) + ((1 / n ** 2) * s2)) + return np.sqrt(((13 / 12) ** m) - ((2 / n) * s1) + ((1 / n**2) * s2)) + + +# --------------------------------------------------------------------------- # +# TESTS +# --------------------------------------------------------------------------- # +# (vectorized measure, looped reference, expected value on resources/discrepancy.x) + +CASES = [ + (centered_l2_discrepancy, centered_l2_discrepancy_loop, 0.3325753), + (l2_discrepancy, l2_discrepancy_loop, 0.01605584), + (l2_star_discrepancy, l2_star_discrepancy_loop, 0.1394512), + (modified_l2_discrepancy, modified_l2_discrepancy_loop, 0.4616604), + (symmetric_l2_discrepancy, symmetric_l2_discrepancy_loop, 0.945297), + (wrap_around_l2_discrepancy, wrap_around_l2_discrepancy_loop, 0.2215735), +] + + +@pytest.fixture(scope="module") +def X(): + return np.loadtxt(path_to_resources("discrepancy.x")) + - return val +@pytest.mark.parametrize("measure, loop, expected", CASES, ids=[c[0].__name__ for c in CASES]) +def test_discrepancy_matches_expected(X, measure, loop, expected): + assert measure(X) == pytest.approx(expected, abs=1e-6) -if __name__ == '__main__': - unittest.main() +@pytest.mark.parametrize("measure, loop, expected", CASES, ids=[c[0].__name__ for c in CASES]) +def test_vectorized_matches_loop(X, measure, loop, expected): + assert measure(X) == pytest.approx(loop(X), abs=1e-8) diff --git a/tests/test_sampling.py b/tests/test_sampling.py index 676c06c..74fb2d6 100644 --- a/tests/test_sampling.py +++ b/tests/test_sampling.py @@ -1,21 +1,18 @@ -import unittest +import numpy as np +import pytest from pysampling.sample import sample +ALGORITHMS = ["random", "lhs", "halton", "sobol"] -class SamplingTest(unittest.TestCase): - def test_random(self): - sample("random", 50, 2, seed=1) +@pytest.mark.parametrize("algorithm", ALGORITHMS) +def test_sample_shape_and_bounds(algorithm): + X = sample(algorithm, 50, 2, seed=1) + assert X.shape == (50, 2) + assert np.all(X >= 0.0) and np.all(X <= 1.0) - def test_lhs(self): - sample("lhs", 50, 2, seed=1) - def test_sobol(self): - sample("sobol", 50, 2, seed=1) - - def test_halton(self): - sample("halton", 50, 2, seed=1) - -if __name__ == '__main__': - unittest.main() +def test_unknown_algorithm_raises(): + with pytest.raises(ValueError): + sample("does-not-exist", 50, 2) diff --git a/tests/test_sobol.py b/tests/test_sobol.py index 70117e2..d1390da 100644 --- a/tests/test_sobol.py +++ b/tests/test_sobol.py @@ -1,34 +1,28 @@ -import unittest - import numpy as np from pysampling.algorithms.sobol import SobolSampling from tests.util import path_to_resources -class SobolTest(unittest.TestCase): - - def test_c_code_with_matlab_low_dim(self): - correct = np.loadtxt(path_to_resources("test_sobol_1.txt"), delimiter=" ") - _val = SobolSampling(setup="burkardt", n_skip=0).sample(200, 2) - self.assertTrue(np.all(np.abs(correct - _val) < 1e-6)) +def test_c_code_with_matlab_low_dim(): + correct = np.loadtxt(path_to_resources("test_sobol_1.txt"), delimiter=" ") + val = SobolSampling(setup="burkardt", n_skip=0).sample(200, 2) + assert np.all(np.abs(correct - val) < 1e-6) - def test_c_code_with_matlab_large_dim(self): - correct = np.loadtxt(path_to_resources("test_sobol_2.txt"), delimiter=" ") - _val = SobolSampling(setup="burkardt", n_skip=0).sample(200, 30) - self.assertTrue(np.all(np.abs(correct - _val) < 1e-4)) - def test_c_code_joekuo(self): - correct = np.loadtxt(path_to_resources("test_sobol_3.txt"), delimiter=" ") - _val = SobolSampling(setup="joekuo", n_skip=0).sample(200, 70) - self.assertTrue(np.all(np.abs(correct - _val) < 1e-4)) +def test_c_code_with_matlab_large_dim(): + correct = np.loadtxt(path_to_resources("test_sobol_2.txt"), delimiter=" ") + val = SobolSampling(setup="burkardt", n_skip=0).sample(200, 30) + assert np.all(np.abs(correct - val) < 1e-4) - def test_matlab_skip(self): - correct = np.loadtxt(path_to_resources("test_sobol_4.txt"), delimiter=",") - _val = SobolSampling(setup="burkardt").sample(20, 2) - self.assertTrue(np.all(np.abs(correct - _val) < 1e-4)) +def test_c_code_joekuo(): + correct = np.loadtxt(path_to_resources("test_sobol_3.txt"), delimiter=" ") + val = SobolSampling(setup="joekuo", n_skip=0).sample(200, 70) + assert np.all(np.abs(correct - val) < 1e-4) -if __name__ == '__main__': - unittest.main() +def test_matlab_skip(): + correct = np.loadtxt(path_to_resources("test_sobol_4.txt"), delimiter=",") + val = SobolSampling(setup="burkardt").sample(20, 2) + assert np.all(np.abs(correct - val) < 1e-4) diff --git a/tests/test_suite.py b/tests/test_suite.py deleted file mode 100644 index 28c96fe..0000000 --- a/tests/test_suite.py +++ /dev/null @@ -1,19 +0,0 @@ -import os -import sys -import unittest - -# add the path to be execute in the main directory -sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) - -testmodules = [ - 'tests.test_discrepancy', - 'tests.test_sobol', - #'tests.test_usage' -] - -suite = unittest.TestSuite() - -for t in testmodules: - suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t)) - -unittest.TextTestRunner().run(suite) \ No newline at end of file diff --git a/tests/util.py b/tests/util.py index 980f915..f5aab37 100644 --- a/tests/util.py +++ b/tests/util.py @@ -2,7 +2,5 @@ def path_to_resources(*args): - l = [os.path.dirname(os.path.realpath(__file__))] - l.append("resources") - l.extend(args) - return os.path.join(*l) + parts = [os.path.dirname(os.path.realpath(__file__)), "resources", *args] + return os.path.join(*parts) diff --git a/~$logo.pptx b/~$logo.pptx deleted file mode 100644 index fa05435533eb61e08be691e245fd960128a56061..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 165 zcmd;e%1O-2)=}^(&B;v6V^AOx@G>|t