From 37e35a97d3916da7f93eee445075f8bbb6cefc51 Mon Sep 17 00:00:00 2001 From: Samuel Vangu Date: Sun, 16 Aug 2026 20:19:19 +0200 Subject: [PATCH 1/2] Add sobol sampler as well as tests and demonstrating notebook --- examples/sobol.ipynb | 357 +++++++++++++++++++++++++++++++++++ src/grid/__init__.py | 11 +- src/grid/sobol.py | 202 ++++++++++++++++++++ src/grid/tests/test_sobol.py | 258 +++++++++++++++++++++++++ 4 files changed, 822 insertions(+), 6 deletions(-) create mode 100644 examples/sobol.ipynb create mode 100644 src/grid/sobol.py create mode 100644 src/grid/tests/test_sobol.py diff --git a/examples/sobol.ipynb b/examples/sobol.ipynb new file mode 100644 index 00000000..a49f2065 --- /dev/null +++ b/examples/sobol.ipynb @@ -0,0 +1,357 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9be9ecff", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/theochem/grid/blob/master/examples/Sobol.ipynb)" + ] + }, + { + "cell_type": "markdown", + "id": "6b11e96d", + "metadata": {}, + "source": [ + "# Sobol' Sequences\n", + "\n", + "The [Sobol](https://grid.qcdevs.org/pyapi/grid.sobol.html#grid.sobol.Sobol)\n", + "grid can be used for integration over a (hyper)cubic or parallelepiped domain.\n", + "Sobol' sequences (Sobol', 1967) are a digital-net construction: points are\n", + "generated in base 2 so that, for any dimension, the elementary base-2\n", + "intervals are filled as evenly as possible. Unlike Monte Carlo, whose error\n", + "decreases as $O(N^{-1/2})$, Sobol' sequences achieve $O((\\log N)^d / N)$ for\n", + "sufficiently smooth (bounded-variation) integrands -- substantially faster\n", + "for large $N$. This notebook builds a Sobol' design, visualizes it in three\n", + "dimensions, and compares it against baselines already in `grid` on two\n", + "integrands from computational chemistry -- one smooth, one not -- to see\n", + "honestly where this advantage does and does not hold." + ] + }, + { + "cell_type": "markdown", + "id": "616f183a", + "metadata": {}, + "source": [ + "## Initialization of Sobol\n", + "\n", + "`Sobol` is initialized by specifying:\n", + "\n", + "1. `n_points` -- the number of integration points $N$. Must be a power of 2\n", + " (e.g. 1024, 2048, ...), for the balance properties of the underlying\n", + " digital-net construction.\n", + "2. `dimension` -- the dimension $d$ of the integration domain.\n", + "3. `seed` (optional) -- for reproducibility, used only when `randomize=True`.\n", + "4. `randomize` (optional, default `True`) -- if `True`, applies Owen\n", + " scrambling to the sequence. If `False`, generates the deterministic,\n", + " unscrambled Sobol' sequence (whose first point is always the origin).\n", + "5. `origin` and `axes` (optional) -- to map the design from the unit\n", + " hypercube $[0,1)^d$ onto an arbitrary parallelepiped.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8744e157", + "metadata": {}, + "outputs": [], + "source": [ + "from grid.sobol import Sobol\n", + "import numpy as np\n", + "\n", + "sobol = Sobol(n_points=16, dimension=2, seed=0)\n", + "print(f\"Number of points: {sobol.size}\")\n", + "print(f\"Dimension: {sobol.dimension}\")\n", + "print(f\"Points are in [0, 1)^2: {(sobol.points >= 0).all() and (sobol.points < 1).all()}\")\n", + "print()\n", + "print(\"Points:\")\n", + "print(sobol.points)" + ] + }, + { + "cell_type": "markdown", + "id": "ffb7ef26", + "metadata": {}, + "source": [ + "With `randomize=False`, the sequence is deterministic and its very first\n", + "point is always the origin -- a defining property of the unscrambled Sobol'\n", + "construction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3d38984", + "metadata": {}, + "outputs": [], + "source": [ + "sobol_plain = Sobol(n_points=16, dimension=2, seed=0, randomize=False)\n", + "sobol_scrambled = Sobol(n_points=16, dimension=2, seed=0, randomize=True)\n", + "\n", + "print(\"First point, randomize=False:\", sobol_plain.points[0])\n", + "print(\"First point, randomize=True: \", sobol_scrambled.points[0])" + ] + }, + { + "cell_type": "markdown", + "id": "6b337efb", + "metadata": {}, + "source": [ + "By default, points live on the unit hypercube $[0,1)^d$. Passing `origin`\n", + "and `axes` maps the design onto an arbitrary parallelepiped, following the\n", + "same convention as `Lattice` and `LatinHypercube`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5af42af5", + "metadata": {}, + "outputs": [], + "source": [ + "origin = np.array([1.0, 2.0])\n", + "axes = np.array([[3.0, 0.0], [0.0, 0.5]])\n", + "sobol_mapped = Sobol(n_points=16, dimension=2, seed=0, origin=origin, axes=axes)\n", + "\n", + "print(f\"Points now lie in [1, 4) x [2, 2.5): \"\n", + " f\"{(sobol_mapped.points[:, 0] >= 1).all() and (sobol_mapped.points[:, 0] < 4).all()}\")\n", + "print(f\"Weight per point (volume / N): {sobol_mapped.weights[0]:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "50ba4d52", + "metadata": {}, + "source": [ + "## A 3D Scatter Plot of the Design\n", + "\n", + "Sobol' points fill space evenly across scales: doubling $N$ refines the\n", + "existing pattern rather than replacing it (the first $N$ points of a\n", + "$2N$-point design are exactly the same $N$ points), which is easy to state\n", + "but worth seeing directly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c089f073", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D # noqa: F401 (registers 3D projection)\n", + "\n", + "sobol3d = Sobol(n_points=512, dimension=3, seed=0)\n", + "\n", + "fig = plt.figure(figsize=(7, 6))\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(\n", + " sobol3d.points[:, 0], sobol3d.points[:, 1], sobol3d.points[:, 2],\n", + " s=15, color=\"#2E5C8A\", alpha=0.7, depthshade=True,\n", + ")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_zlabel(\"z\")\n", + "ax.set_title(f\"Sobol: {sobol3d.size} points in $[0,1)^3$\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "93ec3211", + "metadata": {}, + "source": [ + "## Two Functions From Computational Chemistry\n", + "\n", + "Sobol's real advantage over Monte Carlo comes from the smoothness of the\n", + "integrand (via the Koksma-Hlawka inequality, which requires bounded\n", + "variation) -- not from any additive structure specifically. To see this\n", + "honestly, we compare a smooth integrand against a discontinuous one, both\n", + "grounded in computational chemistry.\n", + "\n", + "**1. Product of Gaussian-type functions (smooth).** A simple,\n", + "separable Gaussian-type-orbital-like model:\n", + "\n", + "$$f(\\mathbf{x}) = \\prod_{i=1}^d \\exp(-\\alpha_i x_i^2)$$\n", + "\n", + "This is infinitely differentiable -- exactly the setting where Sobol's\n", + "low-discrepancy convergence rate should be most visible.\n", + "\n", + "**2. A spherical interaction cutoff (discontinuous).** Interaction cutoffs\n", + "are ubiquitous in molecular simulation: many force fields and pair-potential\n", + "schemes simply ignore interactions beyond a cutoff radius $r_c$ from a\n", + "reference point, for computational efficiency. As an indicator function of\n", + "this cutoff region:\n", + "\n", + "$$f(\\mathbf{x}) = \\mathbb{1}\\left[\\|\\mathbf{x} - \\mathbf{x}_0\\|_2 < r_c\\right]$$\n", + "\n", + "This is discontinuous at the cutoff boundary -- not of bounded variation in\n", + "the sense required by the Koksma-Hlawka inequality -- so Sobol's theoretical\n", + "advantage is expected to largely disappear here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1ed6fbd", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.special import erf, gamma\n", + "\n", + "rng = np.random.default_rng(0)\n", + "DIM = 3\n", + "\n", + "alpha = rng.uniform(0.5, 3.0, size=DIM)\n", + "center = np.full(DIM, 0.5)\n", + "r_cutoff = 0.3 # fully inside [0,1]^3, no boundary clipping\n", + "\n", + "\n", + "def gto_product(x):\n", + " # Product of Gaussian-type functions: f(x) = prod_i exp(-alpha_i x_i^2).\n", + " return np.exp(-(x**2 * alpha[None, :])).prod(axis=1)\n", + "\n", + "\n", + "def gto_product_exact():\n", + " # Exact integral over [0,1]^d, via the error function.\n", + " per_dim = (np.sqrt(np.pi) / (2 * np.sqrt(alpha))) * erf(np.sqrt(alpha))\n", + " return per_dim.prod()\n", + "\n", + "\n", + "def cutoff_indicator(x):\n", + " # Indicator of a spherical interaction cutoff of radius r_cutoff around center.\n", + " return (np.linalg.norm(x - center[None, :], axis=1) < r_cutoff).astype(float)\n", + "\n", + "\n", + "def cutoff_indicator_exact():\n", + " # Exact integral: volume of a d-ball of radius r_cutoff.\n", + " return np.pi ** (DIM / 2) / gamma(DIM / 2 + 1) * r_cutoff**DIM\n", + "\n", + "\n", + "print(f\"Exact integral of the GTO product (smooth): {gto_product_exact():.6f}\")\n", + "print(f\"Exact integral of the cutoff indicator (discont.): {cutoff_indicator_exact():.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "22b6e023", + "metadata": {}, + "source": [ + "## Comparing Against Baselines Already in `grid`\n", + "\n", + "We use `Tensor1DGrids`, built from three `Trapezoidal` 1D grids (`onedgrid`),\n", + "as a structured baseline already present in the library. Like `UniformGrid`,\n", + "`Tensor1DGrids` inherits from `_HyperRectangleGrid` and is restricted to two\n", + "or three dimensions -- one more reason to run this comparison at $d=3$.\n", + "`Trapezoidal` is defined on $[-1,1]$, so its points and weights are remapped\n", + "onto $[0,1]^3$ with a simple affine transformation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5edef2c0", + "metadata": {}, + "outputs": [], + "source": [ + "from grid.onedgrid import Trapezoidal\n", + "from grid.cubic import Tensor1DGrids\n", + "from grid.basegrid import Grid\n", + "\n", + "N_POWERS = [5, 7, 9, 10, 12]\n", + "N_TRIALS = 15\n", + "\n", + "exact_gto = gto_product_exact()\n", + "exact_cut = cutoff_indicator_exact()\n", + "\n", + "sobol_err_gto, mc_err_gto, tensor_err_gto = [], [], []\n", + "sobol_err_cut, mc_err_cut, tensor_err_cut = [], [], []\n", + "n_points_list = []\n", + "\n", + "for m_pow in N_POWERS:\n", + " N = 2 ** m_pow\n", + " n_points_list.append(N)\n", + "\n", + " trial_sobol_gto, trial_mc_gto = [], []\n", + " trial_sobol_cut, trial_mc_cut = [], []\n", + " for trial in range(N_TRIALS):\n", + " sobol = Sobol(n_points=N, dimension=DIM, seed=trial)\n", + " trial_sobol_gto.append(abs(sobol.integrate(gto_product(sobol.points)) - exact_gto))\n", + " trial_sobol_cut.append(abs(sobol.integrate(cutoff_indicator(sobol.points)) - exact_cut))\n", + "\n", + " mc_points = np.random.default_rng(1000 + trial).random((N, DIM))\n", + " mc_weights = np.full(N, 1.0 / N)\n", + " mc_grid = Grid(mc_points, mc_weights)\n", + " trial_mc_gto.append(abs(mc_grid.integrate(gto_product(mc_points)) - exact_gto))\n", + " trial_mc_cut.append(abs(mc_grid.integrate(cutoff_indicator(mc_points)) - exact_cut))\n", + "\n", + " sobol_err_gto.append(np.mean(trial_sobol_gto))\n", + " mc_err_gto.append(np.mean(trial_mc_gto))\n", + " sobol_err_cut.append(np.mean(trial_sobol_cut))\n", + " mc_err_cut.append(np.mean(trial_mc_cut))\n", + "\n", + " m_tensor = int(round(N ** (1 / DIM)))\n", + " oned = Trapezoidal(m_tensor)\n", + " tensor = Tensor1DGrids(oned, oned, oned)\n", + " tensor_points = (tensor.points + 1) / 2\n", + " tensor_weights = tensor.weights / (2 ** DIM)\n", + " tensor_grid = Grid(tensor_points, tensor_weights)\n", + " tensor_err_gto.append(abs(tensor_grid.integrate(gto_product(tensor_points)) - exact_gto))\n", + " tensor_err_cut.append(abs(tensor_grid.integrate(cutoff_indicator(tensor_points)) - exact_cut))\n", + "\n", + "print(\"Done.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f52f312c", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + "axes[0].loglog(n_points_list, mc_err_gto, \"o--\", color=\"#B0413E\", label=\"Monte Carlo\")\n", + "axes[0].loglog(n_points_list, tensor_err_gto, \"^-\", color=\"#4C9A5B\", label=\"Tensor1DGrids (Trapezoidal)\")\n", + "axes[0].loglog(n_points_list, sobol_err_gto, \"s-\", color=\"#2E5C8A\", label=\"Sobol\")\n", + "axes[0].set_xlabel(\"N (number of points)\")\n", + "axes[0].set_ylabel(\"Mean absolute error\")\n", + "axes[0].set_title(r\"Smooth: $\\prod_i \\exp(-\\alpha_i x_i^2)$\" + f\" (d={DIM})\")\n", + "axes[0].legend()\n", + "axes[0].grid(True, which=\"both\", alpha=0.3)\n", + "\n", + "axes[1].loglog(n_points_list, mc_err_cut, \"o--\", color=\"#B0413E\", label=\"Monte Carlo\")\n", + "axes[1].loglog(n_points_list, tensor_err_cut, \"^-\", color=\"#4C9A5B\", label=\"Tensor1DGrids (Trapezoidal)\")\n", + "axes[1].loglog(n_points_list, sobol_err_cut, \"s-\", color=\"#2E5C8A\", label=\"Sobol\")\n", + "axes[1].set_xlabel(\"N (number of points)\")\n", + "axes[1].set_ylabel(\"Mean absolute error\")\n", + "axes[1].set_title(r\"Discontinuous: $\\mathbb{1}[\\|\\mathbf{x}-\\mathbf{x}_0\\| # -- """Grid Module.""" -# ruff: noqa: F401,F403 +# ruff: noqa: F403 from grid.angular import * from grid.atomgrid import * from grid.basegrid import * from grid.becke import * +from grid.coulomb import * from grid.cubic import * from grid.hirshfeld import * -from grid.angular import * from grid.molgrid import * +from grid.ngrid import * from grid.ode import * from grid.onedgrid import * from grid.periodicgrid import * -from grid.rtransform import * -from grid.ngrid import * -from grid.coulomb import * from grid.robust_poisson import * +from grid.rtransform import * +from grid.sobol import * diff --git a/src/grid/sobol.py b/src/grid/sobol.py new file mode 100644 index 00000000..cee83d43 --- /dev/null +++ b/src/grid/sobol.py @@ -0,0 +1,202 @@ +# GRID is a numerical integration module for quantum chemistry. +# +# Copyright (C) 2011-2019 The GRID Development Team +# +# This file is part of GRID. +# +# GRID is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 3 +# of the License, or (at your option) any later version. +# +# GRID is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see +# -- +r"""Sobol' Sequence for Integration on (Hyper)Cubic Grids.""" + +import numpy as np +from scipy.stats import qmc + +from grid.basegrid import Grid + + +class Sobol(Grid): + r"""Sobol' sequence for integration on a (hyper)cubic grid. + + Sobol' sequences are a digital-net construction providing low-discrepancy, + equal-weight integration points for multidimensional integration over the + unit hypercube :math:`[0,1)^d`. Points are generated using scipy's + :class:`scipy.stats.qmc.Sobol`, with points generated on :math:`[0,1)^d` + via ``random_base2`` for the balance properties associated with + powers-of-two sample sizes. + + The integration weights are all equal to :math:`V/N`, where :math:`V` is the volume + of the integration domain. + + References + ---------- + - Sobol', I. M. (1967). On the distribution of points in a cube and the + approximate evaluation of integrals. USSR Computational Mathematics and + Mathematical Physics, 7(4), 86-112. + - Owen, A. B. (2020). On dropping the first Sobol' point. + arXiv:2008.08051. + - SciPy documentation: https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.qmc.Sobol.html + + """ + + def __init__( + self, + n_points, + dimension, + seed=None, + randomize=True, + origin=None, + axes=None, + ): + r"""Construct a Sobol grid. + + Parameters + ---------- + n_points : int + Number of integration points :math:`N`. Must be a power of 2 + (e.g., 1024, 2048, 4096, ...), for the balance properties of the + underlying digital net construction. + dimension : int + Dimension :math:`d` of the integration domain. + seed : int, optional + Seed for the random number generator, used only when + ``randomize=True``. + randomize : bool, optional + If True (default), applies Owen scrambling to the sequence. If + False, generates the unscrambled (deterministic) Sobol' sequence. + origin : np.ndarray, shape (d,), optional + Origin of the hypercube. Defaults to zero vector. + axes : np.ndarray, shape (d, d), optional + Axes defining the hypercube (as row vectors). Defaults to identity + matrix (unit hypercube). The Sobol' points are first generated on + :math:`[0,1)^d` and then affine-transformed to the specified + parallelepiped. + + Raises + ------ + ValueError + If n_points is not a power of 2, or if dimension is less than 1, + or if origin/axes have an incorrect shape, or if axes are not + linearly independent. + + """ + if not self._is_power_of_2(n_points): + raise ValueError(f"n_points must be a power of 2, got {n_points}") + if dimension < 1: + raise ValueError(f"dimension must be >= 1, got {dimension}") + + # Generate Sobol points in the unit cube [0, 1)^d + points_unit = self._generate_sobol_points(n_points, dimension, seed, randomize) + + if origin is None: + origin = np.zeros(dimension) + else: + origin = np.asarray(origin, dtype=float) + if origin.shape != (dimension,): + raise ValueError(f"origin must have shape ({dimension},), got {origin.shape}") + + if axes is None: + axes = np.eye(dimension) + else: + axes = np.asarray(axes, dtype=float) + if axes.shape != (dimension, dimension): + raise ValueError( + f"axes must have shape ({dimension}, {dimension}), got {axes.shape}" + ) + if np.linalg.matrix_rank(axes) < dimension: + raise ValueError("axes must be linearly independent") + + # Map the unit cube points to the parallelepiped defined by origin and axes + # (affine transformation: x = origin + points_unit @ axes) + points = origin + points_unit @ axes + + # Volume of the parallelepiped + volume = np.abs(np.linalg.det(axes)) + + # Uniform weights + weights = np.full(n_points, volume / n_points) + + self._n_points = n_points + self._dimension = dimension + self._seed = seed + self._randomize = randomize + self._origin = origin + self._axes = axes + + super().__init__(points, weights) + + def _generate_sobol_points(self, n_points, dimension, seed, randomize): + r"""Generate Sobol' points on the unit hypercube [0,1)^d. + + Parameters + ---------- + n_points : int + Number of points :math:`N` (a power of 2). + dimension : int + Dimension :math:`d`. + seed : int or None + Seed for the random number generator. + randomize : bool + If True, apply Owen scrambling. If False, generate the + unscrambled sequence. + + Returns + ------- + np.ndarray, shape (N, d) + Sobol' points in the unit hypercube. + + """ + rng = np.random.default_rng(seed) + m = int(np.log2(n_points)) + return qmc.Sobol(d=dimension, scramble=randomize, rng=rng).random_base2(m=m) + + @staticmethod + def _is_power_of_2(n): + """Check if n is a power of 2.""" + return n > 0 and (n & (n - 1)) == 0 + + def __getitem__(self, index): + """Return a plain Grid for a point subset.""" + if isinstance(index, int): + return Grid(np.array([self.points[index]]), np.array([self.weights[index]])) + return Grid(np.array(self.points[index]), np.array(self.weights[index])) + + @property + def n_points(self): + """int: Number of points in the Sobol design.""" + return self._n_points + + @property + def dimension(self): + """int: Dimension of the Sobol grid.""" + return self._dimension + + @property + def seed(self): + """int or None: Seed used for reproducibility.""" + return self._seed + + @property + def randomize(self): + """bool: Whether Owen scrambling is applied (True) or not (False).""" + return self._randomize + + @property + def origin(self): + """np.ndarray: Origin of the integration domain.""" + return self._origin + + @property + def axes(self): + """np.ndarray: Axes defining the integration domain.""" + return self._axes diff --git a/src/grid/tests/test_sobol.py b/src/grid/tests/test_sobol.py new file mode 100644 index 00000000..eba2861f --- /dev/null +++ b/src/grid/tests/test_sobol.py @@ -0,0 +1,258 @@ +# GRID is a numerical integration module for quantum chemistry. +# +# Copyright (C) 2011-2019 The GRID Development Team +# +# This file is part of GRID. +# +# GRID is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 3 +# of the License, or (at your option) any later version. +# +# GRID is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see +# -- +r"""Tests for Sobol' Sequences.""" + +import os +import tempfile +from unittest import TestCase + +import numpy as np +from numpy.testing import assert_allclose, assert_equal + +from grid.basegrid import Grid +from grid.sobol import Sobol + + +class TestSobol(TestCase): + r"""Test Sobol class.""" + + # ------------------------------------------------------------------ + # Validation errors + # ------------------------------------------------------------------ + + def test_raises_error_when_n_points_not_power_of_2(self): + r"""Test that n_points must be a power of 2.""" + with self.assertRaises(ValueError) as err: + Sobol(n_points=100, dimension=2) + self.assertIn("must be a power of 2", str(err.exception)) + + def test_raises_error_when_dimension_invalid(self): + r"""Test that dimension must be >= 1.""" + with self.assertRaises(ValueError) as err: + Sobol(n_points=1024, dimension=0) + self.assertIn("must be >= 1", str(err.exception)) + + def test_raises_error_for_invalid_origin(self): + r"""Test that origin must have correct shape.""" + with self.assertRaises(ValueError) as err: + Sobol(n_points=1024, dimension=3, origin=np.array([0, 0])) + self.assertIn("origin must have shape (3,)", str(err.exception)) + + def test_raises_error_for_invalid_axes(self): + r"""Test that axes must have correct shape.""" + with self.assertRaises(ValueError) as err: + Sobol(n_points=1024, dimension=3, axes=np.eye(2)) + self.assertIn("axes must have shape (3, 3)", str(err.exception)) + + def test_raises_error_for_singular_axes(self): + r"""Test that axes must be linearly independent.""" + singular_axes = np.array([[1, 0, 0], [2, 0, 0], [0, 0, 1]]) + with self.assertRaises(ValueError) as err: + Sobol(n_points=1024, dimension=3, axes=singular_axes) + self.assertIn("must be linearly independent", str(err.exception)) + + # ------------------------------------------------------------------ + # Basic properties, weights, domain mapping + # ------------------------------------------------------------------ + + def test_properties(self): + r"""Test that Sobol properties are correctly set.""" + n_points, dimension = 1024, 3 + sobol = Sobol(n_points=n_points, dimension=dimension, seed=0) + + assert_equal(sobol.size, n_points) + assert_equal(sobol.n_points, n_points) + assert_equal(sobol.dimension, dimension) + assert_equal(sobol.randomize, True) + assert_equal(sobol.points.shape, (n_points, dimension)) + assert_equal(sobol.weights.shape, (n_points,)) + assert_allclose(sobol.origin, np.zeros(dimension)) + assert_allclose(sobol.axes, np.eye(dimension)) + + def test_weights_are_equal(self): + r"""Test that all weights are equal to V/N.""" + n_points, dimension = 1024, 2 + sobol = Sobol(n_points=n_points, dimension=dimension, seed=0) + + expected_weight = 1.0 / n_points + assert_allclose(sobol.weights, np.full(n_points, expected_weight)) + + def test_weights_with_custom_axes(self): + r"""Test that weights scale with volume.""" + n_points, dimension = 1024, 2 + axes = np.array([[2.0, 0.0], [0.0, 2.0]]) + sobol = Sobol(n_points=n_points, dimension=dimension, axes=axes, seed=0) + + expected_weight = 4.0 / n_points + assert_allclose(sobol.weights, np.full(n_points, expected_weight)) + + def test_points_in_unit_cube(self): + r"""Test that points are in [0, 1)^d for default parameters.""" + sobol = Sobol(n_points=1024, dimension=3, seed=0) + assert np.all(sobol.points >= 0.0) + assert np.all(sobol.points < 1.0) + + def test_points_with_custom_origin_and_axes(self): + r"""Test that points are correctly transformed.""" + n_points, dimension = 1024, 2 + origin = np.array([1.0, 2.0]) + axes = np.array([[0.5, 0.0], [0.0, 0.5]]) + sobol = Sobol(n_points=n_points, dimension=dimension, origin=origin, axes=axes, seed=0) + + assert np.all(sobol.points[:, 0] >= 1.0) + assert np.all(sobol.points[:, 0] < 1.5) + assert np.all(sobol.points[:, 1] >= 2.0) + assert np.all(sobol.points[:, 1] < 2.5) + + def test_different_dimensions(self): + r"""Test Sobol in different dimensions.""" + for dimension in [1, 2, 3, 5, 10]: + n_points = 1024 + sobol = Sobol(n_points=n_points, dimension=dimension, seed=0) + assert_equal(sobol.dimension, dimension) + assert_equal(sobol.points.shape, (n_points, dimension)) + + def test_save_and_load(self): + r"""Test saving Sobol grid to file.""" + + sobol = Sobol(n_points=1024, dimension=2, seed=0) + + fd, filename = tempfile.mkstemp(suffix=".npz") + os.close(fd) + + try: + sobol.save(filename) + loaded = np.load(filename) + assert_allclose(loaded["points"], sobol.points) + assert_allclose(loaded["weights"], sobol.weights) + loaded.close() + finally: + if os.path.exists(filename): + os.unlink(filename) + + # ------------------------------------------------------------------ + # Integration accuracy + # ------------------------------------------------------------------ + + def test_integration_of_constant_function(self): + r"""Test integration of f(x) = 1 gives volume.""" + n_points, dimension = 2048, 3 + axes = np.diag([2.0, 3.0, 4.0]) # Volume = 24 + sobol = Sobol(n_points=n_points, dimension=dimension, axes=axes, seed=0) + + func_vals = np.ones(n_points) + integral = sobol.integrate(func_vals) + assert_allclose(integral, 24.0, rtol=1e-10) + + def test_integration_of_linear_function(self): + r"""Test integration of f(x) = x_1 + x_2 on unit square.""" + n_points, dimension = 4096, 2 + sobol = Sobol(n_points=n_points, dimension=dimension, seed=0) + + func_vals = sobol.points[:, 0] + sobol.points[:, 1] + integral = sobol.integrate(func_vals) + + # Exact integral over [0,1]^2: int_0^1 int_0^1 (x+y) dx dy = 1 + assert_allclose(integral, 1.0, rtol=1e-2) + + def test_integration_of_quadratic_function(self): + r"""Test integration of f(x) = x^2 on unit interval.""" + n_points, dimension = 8192, 1 + sobol = Sobol(n_points=n_points, dimension=dimension, seed=0) + + func_vals = sobol.points[:, 0] ** 2 + integral = sobol.integrate(func_vals) + + # Exact integral over [0,1]: int_0^1 x^2 dx = 1/3 + assert_allclose(integral, 1.0 / 3.0, rtol=1e-3) + + # ------------------------------------------------------------------ + # Properties SPECIFIC to Sobol' sequences + # ------------------------------------------------------------------ + + def test_first_point_is_origin_when_unrandomized(self): + r"""Test that the first point (index 0) is the origin when randomize=False. + + This is a defining property of the unscrambled Sobol' construction: + the initial point of the sequence is always the zero vector. + """ + n_points, dimension = 1024, 3 + origin = np.array([1.0, 2.0, 3.0]) + sobol = Sobol( + n_points=n_points, + dimension=dimension, + origin=origin, + randomize=False, + seed=0, + ) + assert_allclose(sobol.points[0], origin) + + def test_randomize_true_and_false_differ(self): + r"""Test that randomize=True and randomize=False give different points. + + With randomize=True, Owen scrambling is applied and even the first + point of the sequence is no longer the origin. + """ + n_points, dimension = 1024, 3 + sobol_scrambled = Sobol(n_points=n_points, dimension=dimension, seed=1, randomize=True) + sobol_plain = Sobol(n_points=n_points, dimension=dimension, seed=1, randomize=False) + + assert not np.allclose(sobol_scrambled.points, sobol_plain.points) + assert not np.allclose(sobol_scrambled.points[0], np.zeros(dimension)) + + def test_reproducibility_same_seed(self): + r"""Test that the same seed gives identical points.""" + sobol1 = Sobol(n_points=1024, dimension=2, seed=42) + sobol2 = Sobol(n_points=1024, dimension=2, seed=42) + assert_allclose(sobol1.points, sobol2.points) + + def test_different_seeds_give_different_points(self): + r"""Test that different seeds give different points when randomize=True.""" + sobol1 = Sobol(n_points=1024, dimension=2, seed=42) + sobol2 = Sobol(n_points=1024, dimension=2, seed=43) + assert not np.allclose(sobol1.points, sobol2.points) + + def test_first_n_points_match_prefix_of_larger_sequence(self): + r"""Test that the first N points exactly match the first N points of a 2N design. + + This nesting property lets a Sobol' design be extended to more points + without discarding the ones already computed -- unlike a design that + must be regenerated from scratch to add more points. + """ + n_points, dimension = 512, 3 + sobol_n = Sobol(n_points=n_points, dimension=dimension, seed=0, randomize=False) + sobol_2n = Sobol(n_points=2 * n_points, dimension=dimension, seed=0, randomize=False) + + assert_allclose(sobol_n.points, sobol_2n.points[:n_points]) + + def test_getitem_returns_plain_grid(self): + r"""Test that indexing returns a plain Grid, not a Sobol instance.""" + + sobol = Sobol(n_points=1024, dimension=2, seed=0) + + single = sobol[3] + assert isinstance(single, Grid) + assert not isinstance(single, Sobol) + assert_equal(single.points.shape, (1, 2)) + + subset = sobol[5:10] + assert isinstance(subset, Grid) + assert not isinstance(subset, Sobol) + assert_equal(subset.points.shape, (5, 2)) From c02dbebe8b03e9449805f6bd3512fd5eda29b56b Mon Sep 17 00:00:00 2001 From: Samuel Vangu Date: Sun, 16 Aug 2026 22:07:22 +0200 Subject: [PATCH 2/2] Executing the notebook --- examples/sobol.ipynb | 119 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 104 insertions(+), 15 deletions(-) diff --git a/examples/sobol.ipynb b/examples/sobol.ipynb index a49f2065..68cb5946 100644 --- a/examples/sobol.ipynb +++ b/examples/sobol.ipynb @@ -51,10 +51,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "8744e157", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of points: 16\n", + "Dimension: 2\n", + "Points are in [0, 1)^2: True\n", + "\n", + "Points:\n", + "[[0.40994959 0.96412022]\n", + " [0.72191166 0.10752478]\n", + " [0.90486641 0.52855152]\n", + " [0.21716429 0.4144447 ]\n", + " [0.08928089 0.69382919]\n", + " [0.7769525 0.36244019]\n", + " [0.59979601 0.75002242]\n", + " [0.28786446 0.17711373]\n", + " [0.33251358 0.56666789]\n", + " [0.5200631 0.48545926]\n", + " [0.85267233 0.87717579]\n", + " [0.04086285 0.05408841]\n", + " [0.16880727 0.83739439]\n", + " [0.98064727 0.23061095]\n", + " [0.64211774 0.6552854 ]\n", + " [0.45453768 0.29136491]]\n" + ] + } + ], "source": [ "from grid.sobol import Sobol\n", "import numpy as np\n", @@ -80,10 +108,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "d3d38984", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First point, randomize=False: [0. 0.]\n", + "First point, randomize=True: [0.40994959 0.96412022]\n" + ] + } + ], "source": [ "sobol_plain = Sobol(n_points=16, dimension=2, seed=0, randomize=False)\n", "sobol_scrambled = Sobol(n_points=16, dimension=2, seed=0, randomize=True)\n", @@ -104,10 +141,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "5af42af5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Points now lie in [1, 4) x [2, 2.5): True\n", + "Weight per point (volume / N): 0.0938\n" + ] + } + ], "source": [ "origin = np.array([1.0, 2.0])\n", "axes = np.array([[3.0, 0.0], [0.0, 0.5]])\n", @@ -133,10 +179,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "c089f073", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "from mpl_toolkits.mplot3d import Axes3D # noqa: F401 (registers 3D projection)\n", @@ -193,10 +250,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "c1ed6fbd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exact integral of the GTO product (smooth): 0.349220\n", + "Exact integral of the cutoff indicator (discont.): 0.113097\n" + ] + } + ], "source": [ "from scipy.special import erf, gamma\n", "\n", @@ -250,10 +316,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "5edef2c0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done.\n" + ] + } + ], "source": [ "from grid.onedgrid import Trapezoidal\n", "from grid.cubic import Tensor1DGrids\n", @@ -305,10 +379,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "f52f312c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", "\n", @@ -351,7 +436,11 @@ ] } ], - "metadata": {}, + "metadata": { + "language_info": { + "name": "python" + } + }, "nbformat": 4, "nbformat_minor": 5 }