sparse-grid 0.1.0__py3-none-any.whl

sparse_grid/__init__.py

@@ -0,0 +1,11 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .grid import SparseGrid
+
+
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = ["SparseGrid"]

sparse_grid/grid.py

@@ -0,0 +1,208 @@
+"""Sparse-grid container and algorithms."""
+
+from __future__ import annotations
+
+import copy
+import math
+
+from .point import GridPoint
+from .utils import cross, eval_basis_1d
+
+
+EVEN_DIVISOR = 2
+
+
+class SparseGrid:
+    """Regular sparse grid over a box domain.
+
+    A grid is defined by:
+    - `dim`: number of dimensions,
+    - `level`: sparse-grid level,
+    - `indices`: generated hierarchical indices,
+    - `g_p`: map from index tuple to `GridPoint`.
+    """
+
+    def __init__(self, dim: int = 1, level: int = 1) -> None:
+        self.dim = dim
+        self.level = level
+        self.g_p: dict[tuple[int, ...], GridPoint] = {}
+        self.indices: list[list[int]] = []
+        self.domain = ((0.0, 1.0),) * dim
+        self.action = self.eval_action
+
+    def print_grid(self) -> None:
+        """Print the currently active hierarchical subspace index."""
+        print(self.h_space)
+
+    def eval_action(self) -> None:
+        """Accumulate contribution of the current hierarchical subspace."""
+        basis = copy.deepcopy(self.eval_per_dim[0][self.h_space[0] - 1][0])
+        value = self.eval_per_dim[0][self.h_space[0] - 1][1]
+        for i in range(1, self.dim):
+            value *= self.eval_per_dim[i][self.h_space[i] - 1][1]
+            basis += self.eval_per_dim[i][self.h_space[i] - 1][0]
+        self.value += self.g_p[tuple(basis)].hv * value
+
+    def eval_funct(self, x: list[float]) -> float:
+        """Evaluate a sparse grid function.
+
+        Hierarchical values have to be set.
+
+        Parameters
+        ----------
+        x
+            Evaluation point in physical coordinates.
+
+        Returns
+        -------
+        float
+            Evaluated sparse-grid function value at `x`.
+        """
+        self.value = 0.0
+        self.eval_per_dim: list[list[list[list[int]] | float]] = []
+        for i in range(self.dim):
+            self.eval_per_dim.append([])
+            for j in range(1, self.level + 1):
+                pos = (x[i] - self.domain[i][0]) / (
+                    self.domain[i][1] - self.domain[i][0]
+                )
+                basis = int(math.ceil(pos * 2 ** (j - 1)) * 2 - 1)
+                if basis == -1:
+                    basis = 1
+                    self.eval_per_dim[i].append([[j, basis]])
+                else:
+                    self.eval_per_dim[i].append([[j, basis]])
+                self.eval_per_dim[i][j - 1].append(
+                    eval_basis_1d(
+                        x[i], self.eval_per_dim[i][j - 1][0], self.domain[i]
+                    )
+                )
+        self.action = self.eval_action
+        self.loop_hier_spaces()
+        return self.value
+
+    def loop_hier_spaces(self) -> None:
+        """Iterate over all hierarchical subspaces of the sparse grid."""
+        for i in range(1, self.level + 1):
+            self.h_space = [i]
+            self.loop_hier_spaces_rec(self.dim - 1, self.level - (i - 1))
+
+    def loop_hier_spaces_rec(self, dim: int, level: int) -> None:
+        """Recursively traverse hierarchical subspaces.
+
+        Parameters
+        ----------
+        dim
+            Remaining dimensions to recurse through.
+        level
+            Remaining level budget for sparse-grid admissibility.
+        """
+        if dim > 1:
+            for i in range(1, level + 1):
+                self.h_space.append(i)
+                self.loop_hier_spaces_rec(dim - 1, level - (i - 1))
+                self.h_space.pop()
+        else:
+            for i in range(1, level + 1):
+                self.h_space.append(i)
+                self.action()
+                self.h_space.pop()
+
+    def generate_points(self) -> None:
+        """Generate sparse-grid indices and corresponding `GridPoint` values."""
+        self.indices = self.generate_points_rec(self.dim, self.level)
+        for i in range(len(self.indices)):
+            self.g_p[tuple(self.indices[i])] = GridPoint(
+                self.indices[i], self.domain
+            )
+
+    def generate_points_rec(
+        self, dim: int, level: int, cur_level: int | None = None
+    ) -> list[list[int]]:
+        """Run over all hierarchical subspaces and add all their indices.
+
+        Returns
+        -------
+        list[list[int]]
+            All generated sparse-grid multi-indices.
+        """
+        basis_cur = []
+        if cur_level is None:
+            cur_level = 1
+        for i in range(1, 2 ** (cur_level) + 1, 2):
+            basis_cur.append([cur_level, i])
+        if dim == 1 and cur_level == level:
+            return basis_cur
+        if dim == 1:
+            basis_cur += self.generate_points_rec(dim, level, cur_level + 1)
+            return basis_cur
+        if cur_level == level:
+            return cross(
+                basis_cur,
+                self.generate_points_rec(dim - 1, level - cur_level + 1),
+            )
+        return cross(
+            basis_cur, self.generate_points_rec(dim - 1, level - cur_level + 1)
+        ) + self.generate_points_rec(dim, level, cur_level + 1)
+
+    def nodal_2_hier_1d(
+        self, node: list[int], i: int, j: int, dim: int
+    ) -> None:
+        """Apply one-dimensional nodal-to-hierarchical transform.
+
+        Parameters
+        ----------
+        node
+            Fixed index components from all dimensions except `dim`.
+        i
+            Level index in transformed dimension.
+        j
+            Position index in transformed dimension.
+        dim
+            Dimension currently being transformed.
+        """
+        left = [i - 1, j // 2]
+        right = [i - 1, j // 2 + 1]
+        while left[1] % EVEN_DIVISOR == 0 and left[0] > 0:
+            left = [left[0] - 1, left[1] // EVEN_DIVISOR]
+        while right[1] % EVEN_DIVISOR == 0 and right[0] > 0:
+            right = [right[0] - 1, right[1] // EVEN_DIVISOR]
+        if len(node) > EVEN_DIVISOR:
+            pre_cur_dim = node[0 : 2 * dim]
+            post_cur_dim = node[2 * dim : len(node) + 1]
+            index = [*pre_cur_dim, i, j, *post_cur_dim]
+            left = [*pre_cur_dim, *left, *post_cur_dim]
+            right = [*pre_cur_dim, *right, *post_cur_dim]
+        elif dim == 0:
+            index = [i, j, *node]
+            left += node
+            right += node
+        else:
+            index = [*node, i, j]
+            left = [*node, *left]
+            right = [*node, *right]
+
+        if left[2 * dim] == 0:
+            if right[2 * dim] != 0:
+                self.g_p[tuple(index)].hv -= 0.5 * self.g_p[tuple(right)].hv
+        elif right[2 * dim] == 0:
+            self.g_p[tuple(index)].hv -= 0.5 * self.g_p[tuple(left)].hv
+        else:
+            self.g_p[tuple(index)].hv -= 0.5 * (
+                self.g_p[tuple(left)].hv + self.g_p[tuple(right)].hv
+            )
+
+    def nodal_2_hier(self) -> None:
+        """Convert all nodal values in the grid to hierarchical values."""
+        for i in range(len(self.indices)):
+            self.g_p[tuple(self.indices[i])].hv = self.g_p[
+                tuple(self.indices[i])
+            ].fv
+        for d in range(self.dim):
+            for i in range(self.level, 0, -1):
+                indices = self.generate_points_rec(
+                    self.dim - 1, self.level - i + 1
+                )
+                for j in range(1, 2**i + 1, 2):
+                    for k in range(len(indices)):
+                        self.nodal_2_hier_1d(indices[k], i, j, d)

sparse_grid/point.py

@@ -0,0 +1,65 @@
+"""Point model used by sparse-grid containers."""
+
+from __future__ import annotations
+
+
+class GridPoint:
+    """Representation of a sparse-grid point.
+
+    Stores the Cartesian position and both nodal (`fv`) and hierarchical
+    (`hv`) function values.
+    """
+
+    def __init__(
+        self,
+        index: list[int] | None = None,
+        domain: tuple[tuple[float, float], ...] | None = None,
+    ) -> None:
+        self.hv: float = 0.0
+        self.fv: float = 0.0
+        if index is None:
+            self.pos: list[float] = []
+        else:
+            self.pos = self.point_position(index, domain)
+
+    @staticmethod
+    def point_position(
+        index: list[int], domain: tuple[tuple[float, float], ...] | None = None
+    ) -> list[float]:
+        """Convert a level/position index into physical coordinates.
+
+        Parameters
+        ----------
+        index
+            Interleaved multi-index `[l_1, p_1, ..., l_d, p_d]`.
+        domain
+            Optional domain bounds per dimension. If omitted, `[0, 1]^d`
+            is assumed.
+
+        Returns
+        -------
+        list[float]
+            Point coordinates in physical space.
+        """
+        coord = []
+        if domain is None:
+            for i in range(len(index) // 2):
+                coord.append(index[2 * i + 1] / 2.0 ** index[2 * i])
+        else:
+            for i in range(len(index) // 2):
+                coord.append(
+                    (domain[i][1] - domain[i][0])
+                    * index[2 * i + 1]
+                    / 2.0 ** index[2 * i]
+                    + domain[i][0]
+                )
+        return coord
+
+    def print_point(self) -> None:
+        """Print point coordinates as a tab-separated line."""
+        if not self.pos:
+            return
+        out = ""
+        for i in range(len(self.pos)):
+            out += str(self.pos[i]) + "\t"
+        print(out)

sparse_grid/utils.py

@@ -0,0 +1,48 @@
+"""Utility functions for sparse-grid basis and index operations."""
+
+from __future__ import annotations
+
+
+def cross(*args: list[list[int]]) -> list[list[int]]:
+    """Compute pairwise cross-product (concatenation) of two index lists.
+
+    Parameters
+    ----------
+    *args
+        Two index collections to combine.
+
+    Returns
+    -------
+    list[list[int]]
+        Cross-product of index lists.
+    """
+    ans: list[list[int]] = []
+    for arg in args[0]:
+        for arg2 in args[1]:
+            ans.append([*arg, *arg2])
+    return ans
+
+
+def eval_basis_1d(
+    x: float, basis: list[int], interval: tuple[float, float] | None = None
+) -> float:
+    """Evaluate a one-dimensional hat basis function.
+
+    Parameters
+    ----------
+    x
+        Evaluation coordinate.
+    basis
+        Basis index as `[level, position]`.
+    interval
+        Optional physical interval. If omitted, `[0, 1]` is used.
+
+    Returns
+    -------
+    float
+        Value of 1-D hat basis at `x`.
+    """
+    if interval is None:
+        return 1.0 - abs(x * 2 ** basis[0] - basis[1])
+    pos = (x - interval[0]) / (interval[1] - interval[0])
+    return 1.0 - abs(pos * 2 ** basis[0] - basis[1])

sparse_grid-0.1.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: sparse_grid
+Version: 0.1.0
+Summary: A Python Sparse Grid Package
+Project-URL: homepage, https://eggzec.github.io/sparse_grid/
+Project-URL: documentation, https://eggzec.github.io/sparse_grid/
+Project-URL: source, https://github.com/eggzec/sparse_grid
+Project-URL: releasenotes, https://github.com/eggzec/sparse_grid/releases/latest
+Project-URL: issues, https://github.com/eggzec/sparse_grid/issues
+Author-email: John Burkardt <jvb25@pitt.edu>
+Maintainer-email: Saud Zahir <m.saud.zahir@gmail.com>, M Laraib Ali <laraibg786@outlook.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: python,sparse grids
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# sparse_grid
+A Python Sparse Grid Package

sparse_grid-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+sparse_grid/__init__.py,sha256=sUxwtupOjnr1kpS7sq_Eew7p1xGDL8PJnZHFVkUrPVA,217
+sparse_grid/grid.py,sha256=x8WTyrJoUfcFL8Kr3TFIghjteybnoETXbXPCR9G05HQ,7329
+sparse_grid/point.py,sha256=TMosHAVx1YjHEh5hbVdbtfYWWhP5pdaM9hLj0WtnBXY,1880
+sparse_grid/utils.py,sha256=sGB1o0XkDg6VqyAsBqz9vcQfoi457yTcU-6NYpEmc84,1181
+sparse_grid-0.1.0.dist-info/METADATA,sha256=ao51leYce0OYaNf_JEUaRSiZB_N-yPhpt_de7uop1wA,1659
+sparse_grid-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sparse_grid-0.1.0.dist-info/licenses/LICENSE,sha256=c-1kDTg-Q5oCK9YE5DaPC3Mu5pbw-WGcCljrX8Y1b6c,1493
+sparse_grid-0.1.0.dist-info/RECORD,,

sparse_grid-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sparse_grid-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, eggzec
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.