ndim_ds 0.1.0__tar.gz

ndim_ds-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: ndim_ds
+Version: 0.1.0
+Summary: A collection of optimized N-dimensional data structures in Python
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# N-Dimensional Data Structures
+
+A blazing-fast, polyglot (Python & C++) library providing generalized $N$-dimensional data structures. 
+
+Whether you are working in Python for data science and backend engineering, or you need highly-optimized header-only C++ templates to copy-paste into competitive programming platforms like Codeforces and LeetCode, this repository has you covered.
+
+## Data Structures Included
+All structures support $O(1)$ or $O(\log^N(V))$ operations scaled effortlessly across any arbitrary number of dimensions.
+
+1. **Static N-Dim Prefix Sum** (`static_n_dim_prefix_sum`)
+2. **Static N-Dim Difference Array** (`static_n_dim_difference_array`)
+3. **Dynamic N-Dim Fenwick Tree** (`dynamic_n_dim_fenwick_tree`)
+4. **Dynamic N-Dim Difference Fenwick Tree** (`dynamic_n_dim_diff_fenwick_tree`)
+5. **Dynamic N-Dim Range Fenwick Tree** (`dynamic_n_dim_range_fenwick_tree`)
+6. **Dynamic N-Dim Segment Tree** (`dynamic_n_dim_seg_tree`)
+
+---
+
+## C++ (Competitive Programming)
+
+The `cpp/include/ndim/` directory contains highly optimized, header-only C++17 templates designed specifically for **competitive programming**.
+
+They use standard `<bits/stdc++.h>` format with `using namespace std;` to ensure they are instantly copy-pasteable into online judges without causing scope or header errors. Memory is maintained via flat, contiguous 1D vectors mapped algebraically to $N$ dimensions, preventing memory scattering and ensuring maximum CPU cache efficiency.
+
+### Example Usage
+```cpp
+#include "dynamic_n_dim_seg_tree.hpp"
+
+// Example: 3D Segment Tree using std::min
+auto min_func = [](int64_t a, int64_t b) { return min(a, b); };
+int64_t def = 1e18; // infinity
+
+// 4x4x4 grid
+DynamicNDimSegTree<int64_t, decltype(min_func)> tree({4, 4, 4}, min_func, def);
+
+tree.update({1, 1, 1}, 5);
+tree.update({2, 2, 2}, 10);
+
+int64_t val = tree.query_range({0, 0, 0}, {3, 3, 3}); // 5
+```
+
+---
+
+## Python (Data Science / General)
+
+The `python/src/` directory contains the pure-Python implementations. They use 1D list-flattening mathematics similar to numpy under the hood, but operate purely on standard library primitives, ensuring maximum portability without heavy C-extension dependencies.
+
+### Installation
+The library is configured using `uv` via `pyproject.toml`.
+```bash
+cd python
+uv sync
+```
+
+### Example Usage
+```python
+from dynamic_n_dim_range_fenwick_tree import DynamicNDimRangeFenwickTree
+
+# 10x10x10 grid
+tree = DynamicNDimRangeFenwickTree([10, 10, 10])
+
+# Add 50 to the bounding box from (1, 1, 1) to (5, 5, 5)
+tree.add_range([1, 1, 1], [5, 5, 5], 50)
+
+# Query the volume sum from (0, 0, 0) to (3, 3, 3)
+total = tree.query_range([0, 0, 0], [3, 3, 3])
+```
+
+## Testing
+
+Both ecosystems are rigorously tested with aggressive $10^3$ iteration stress tests across $5$-dimensional constraints.
+- **Python**: Uses `pytest`. Run `uv run pytest test/`
+- **C++**: Uses `doctest`. Compile the files in `cpp/test/` using `g++ -std=c++17` and run the resulting executables.

ndim_ds-0.1.0/README.md

@@ -0,0 +1,73 @@
+# N-Dimensional Data Structures
+
+A blazing-fast, polyglot (Python & C++) library providing generalized $N$-dimensional data structures. 
+
+Whether you are working in Python for data science and backend engineering, or you need highly-optimized header-only C++ templates to copy-paste into competitive programming platforms like Codeforces and LeetCode, this repository has you covered.
+
+## Data Structures Included
+All structures support $O(1)$ or $O(\log^N(V))$ operations scaled effortlessly across any arbitrary number of dimensions.
+
+1. **Static N-Dim Prefix Sum** (`static_n_dim_prefix_sum`)
+2. **Static N-Dim Difference Array** (`static_n_dim_difference_array`)
+3. **Dynamic N-Dim Fenwick Tree** (`dynamic_n_dim_fenwick_tree`)
+4. **Dynamic N-Dim Difference Fenwick Tree** (`dynamic_n_dim_diff_fenwick_tree`)
+5. **Dynamic N-Dim Range Fenwick Tree** (`dynamic_n_dim_range_fenwick_tree`)
+6. **Dynamic N-Dim Segment Tree** (`dynamic_n_dim_seg_tree`)
+
+---
+
+## C++ (Competitive Programming)
+
+The `cpp/include/ndim/` directory contains highly optimized, header-only C++17 templates designed specifically for **competitive programming**.
+
+They use standard `<bits/stdc++.h>` format with `using namespace std;` to ensure they are instantly copy-pasteable into online judges without causing scope or header errors. Memory is maintained via flat, contiguous 1D vectors mapped algebraically to $N$ dimensions, preventing memory scattering and ensuring maximum CPU cache efficiency.
+
+### Example Usage
+```cpp
+#include "dynamic_n_dim_seg_tree.hpp"
+
+// Example: 3D Segment Tree using std::min
+auto min_func = [](int64_t a, int64_t b) { return min(a, b); };
+int64_t def = 1e18; // infinity
+
+// 4x4x4 grid
+DynamicNDimSegTree<int64_t, decltype(min_func)> tree({4, 4, 4}, min_func, def);
+
+tree.update({1, 1, 1}, 5);
+tree.update({2, 2, 2}, 10);
+
+int64_t val = tree.query_range({0, 0, 0}, {3, 3, 3}); // 5
+```
+
+---
+
+## Python (Data Science / General)
+
+The `python/src/` directory contains the pure-Python implementations. They use 1D list-flattening mathematics similar to numpy under the hood, but operate purely on standard library primitives, ensuring maximum portability without heavy C-extension dependencies.
+
+### Installation
+The library is configured using `uv` via `pyproject.toml`.
+```bash
+cd python
+uv sync
+```
+
+### Example Usage
+```python
+from dynamic_n_dim_range_fenwick_tree import DynamicNDimRangeFenwickTree
+
+# 10x10x10 grid
+tree = DynamicNDimRangeFenwickTree([10, 10, 10])
+
+# Add 50 to the bounding box from (1, 1, 1) to (5, 5, 5)
+tree.add_range([1, 1, 1], [5, 5, 5], 50)
+
+# Query the volume sum from (0, 0, 0) to (3, 3, 3)
+total = tree.query_range([0, 0, 0], [3, 3, 3])
+```
+
+## Testing
+
+Both ecosystems are rigorously tested with aggressive $10^3$ iteration stress tests across $5$-dimensional constraints.
+- **Python**: Uses `pytest`. Run `uv run pytest test/`
+- **C++**: Uses `doctest`. Compile the files in `cpp/test/` using `g++ -std=c++17` and run the resulting executables.

ndim_ds-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "ndim_ds"
+version = "0.1.0"
+description = "A collection of optimized N-dimensional data structures in Python"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = []
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=8.0.0",
+    "ruff>=0.4.0",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["test"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+ignore = []

ndim_ds-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ndim_ds-0.1.0/src/dynamic_n_dim_diff_fenwick_tree.py

@@ -0,0 +1,101 @@
+import itertools
+
+
+class DynamicNDimDiffFenwickTree:
+    def __init__(self, dims):
+        """
+        Initializes an N-dimensional dynamic difference array powered by a Fenwick Tree.
+        This structure is optimized for applying values across continuous ranges
+        and querying the exact value of any single point dynamically.
+
+        The grid uses 0-based indexing and allocates memory strictly for the requested
+        dimensions to prevent exponential memory bloat.
+
+        Args:
+            dims (iterable of int): The strict maximum size of the grid in each dimension.
+                                    For example, dims=[10, 10, 10] creates a 3D grid
+                                    allowing coordinates from (0,0,0) to (9,9,9).
+        """
+        self.n = len(dims)
+        self.dims = tuple(dims)
+
+        self.strides = [1] * self.n
+        for i in range(self.n - 2, -1, -1):
+            self.strides[i] = self.strides[i + 1] * self.dims[i + 1]
+
+        self.total_size = self.strides[0] * self.dims[0]
+        self.arr = [0] * self.total_size
+
+    def _add_point(self, coords, val):
+        """
+        Internal helper method to apply a value to a specific point in the Fenwick Tree.
+        Uses 1-based bitwise traversal mapped safely to the 0-based flat array.
+        """
+        dim_indices = []
+        for d in range(self.n):
+            idx_list = []
+            i = coords[d] + 1
+            while i <= self.dims[d]:
+                idx_list.append((i - 1) * self.strides[d])
+                i += i & (-i)
+            dim_indices.append(idx_list)
+
+        for offsets in itertools.product(*dim_indices):
+            self.arr[sum(offsets)] += val
+
+    def add_range(self, x_coords, y_coords, val):
+        """
+        Dynamically adds a value to all elements within an N-dimensional bounding box.
+        Places 2^N markers at the boundaries using the Inclusion-Exclusion principle.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices (lower bounds) of the bounding box.
+            y_coords (iterable of int): 0-based ending indices (inclusive upper bounds).
+            val (int or float): The value to add to every point inside the specified range.
+        """
+        for mask in range(1 << self.n):
+            p_coords = [0] * self.n
+            sign = 1
+            valid = True
+
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = y_coords[d] + 1
+                    if c >= self.dims[d]:
+                        valid = False
+                        break
+                    p_coords[d] = c
+                    sign = -sign
+                else:
+                    p_coords[d] = x_coords[d]
+
+            if valid:
+                self._add_point(p_coords, sign * val)
+
+    def query_point(self, coords):
+        """
+        Retrieves the exact, current value at a specific point in the N-dimensional grid.
+        Since this tree stores a difference array, a point's value is calculated
+        by summing all the difference markers from the origin up to the given coordinates.
+
+        Args:
+            coords (iterable of int): 0-based coordinates of the exact point to query.
+
+        Returns:
+            int or float: The current cumulative value at the specified point.
+        """
+        dim_indices = []
+        for d in range(self.n):
+            idx_list = []
+            i = coords[d] + 1
+            i = min(i, self.dims[d])
+            while i > 0:
+                idx_list.append((i - 1) * self.strides[d])
+                i -= i & (-i)
+            dim_indices.append(idx_list)
+
+        res = 0
+        for offsets in itertools.product(*dim_indices):
+            res += self.arr[sum(offsets)]
+
+        return res

ndim_ds-0.1.0/src/dynamic_n_dim_fenwick_tree.py

@@ -0,0 +1,111 @@
+import itertools
+
+
+class DynamicNDimFenwickTree:
+    def __init__(self, dims):
+        """
+        Initializes an N-dimensional dynamic grid (Fenwick Tree / Binary Indexed Tree)
+        capable of processing point updates and range queries in logarithmic time.
+
+        The grid uses 0-based indexing and allocates memory strictly for the requested
+        dimensions, ensuring no wasted padding space.
+
+        Args:
+            dims (iterable of int): The strict maximum size of the grid in each dimension.
+                                    For example, dims=[5, 5] allows coordinates from (0,0) to (4,4).
+        """
+        self.n = len(dims)
+        self.dims = tuple(dims)
+
+        self.strides = [1] * self.n
+        for i in range(self.n - 2, -1, -1):
+            self.strides[i] = self.strides[i + 1] * self.dims[i + 1]
+
+        self.total_size = self.strides[0] * self.dims[0]
+        self.arr = [0] * self.total_size
+
+    def add(self, coords, val):
+        """
+        Adds a value to a specific single point in the N-dimensional grid.
+        This operation updates the internal tree structure dynamically.
+
+        Args:
+            coords (iterable of int): 0-based coordinate indices of the point to update.
+                                      Must be of length N.
+            val (int or float): The value to add to the specified point.
+        """
+        dim_indices = []
+        for d in range(self.n):
+            idx_list = []
+            i = coords[d] + 1
+            while i <= self.dims[d]:
+                idx_list.append((i - 1) * self.strides[d])
+                i += i & (-i)
+            dim_indices.append(idx_list)
+
+        for offsets in itertools.product(*dim_indices):
+            self.arr[sum(offsets)] += val
+
+    def query_prefix(self, coords):
+        """
+        Calculates the dynamic sum of all elements from the origin (0, 0, ...)
+        up to and including the given coordinates.
+
+        Args:
+            coords (iterable of int): 0-based ending indices (inclusive).
+                                      Must be of length N.
+
+        Returns:
+            int or float: The prefix sum from the origin to the specified coordinates.
+        """
+        dim_indices = []
+        for d in range(self.n):
+            idx_list = []
+            i = coords[d] + 1
+            i = min(i, self.dims[d])
+            while i > 0:
+                idx_list.append((i - 1) * self.strides[d])
+                i -= i & (-i)
+            dim_indices.append(idx_list)
+
+        res = 0
+        for offsets in itertools.product(*dim_indices):
+            res += self.arr[sum(offsets)]
+
+        return res
+
+    def query_range(self, x_coords, y_coords):
+        """
+        Calculates the dynamic sum of all elements within an N-dimensional bounding box.
+        Uses the Inclusion-Exclusion principle over the $2^N$ vertices of the hyper-rectangle.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices (lower bounds)
+                of the bounding box.
+            y_coords (iterable of int): 0-based ending indices (inclusive upper bounds)
+                of the bounding box.
+
+        Returns:
+            int or float: The sum of the elements within the specified bounding box.
+        """
+        ans = 0
+        for mask in range(1 << self.n):
+            q_coords = [0] * self.n
+            sign = 1
+            valid = True
+
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = x_coords[d] - 1
+                    if c < 0:
+                        valid = False
+                        break
+                    q_coords[d] = c
+                    sign = -sign
+                else:
+                    q_coords[d] = y_coords[d]
+
+            if valid:
+                ans += sign * self.query_prefix(q_coords)
+
+        return ans

ndim_ds-0.1.0/src/dynamic_n_dim_range_fenwick_tree.py

@@ -0,0 +1,145 @@
+import itertools
+
+
+class DynamicNDimRangeFenwickTree:
+    def __init__(self, dims):
+        """
+        Initializes an N-dimensional Fenwick Tree capable of processing BOTH
+        dynamic range updates and dynamic range queries in logarithmic time.
+
+        This relies on the "2^N Algebraic Expansion Trick", maintaining 2^N
+        virtual trees packed tightly into a single array to compute spatial volumes.
+
+        Args:
+            dims (iterable of int): The strict maximum size of the grid in each dimension.
+                                    Memory footprint is O(2^N * D_0 * D_1 * ... * D_n).
+        """
+        self.n = len(dims)
+        self.dims = tuple(dims)
+        self.num_masks = 1 << self.n
+
+        self.strides = [1] * self.n
+        for i in range(self.n - 2, -1, -1):
+            self.strides[i] = self.strides[i + 1] * self.dims[i + 1]
+
+        self.total_size = self.strides[0] * self.dims[0]
+        self.arr = [[0] * self.num_masks for _ in range(self.total_size)]
+
+    def _add_point(self, coords, val):
+        """
+        Internal method. Updates all 2^N algebraic states at a specific point.
+        """
+        mask_vals = [0] * self.num_masks
+        for mask in range(self.num_masks):
+            v = val
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    v *= -(coords[d] + 1)
+            mask_vals[mask] = v
+
+        dim_indices = []
+        for d in range(self.n):
+            idx_list = []
+            i = coords[d] + 1
+            while i <= self.dims[d]:
+                idx_list.append((i - 1) * self.strides[d])
+                i += i & (-i)
+            dim_indices.append(idx_list)
+
+        for offsets in itertools.product(*dim_indices):
+            idx = sum(offsets)
+            for mask in range(self.num_masks):
+                self.arr[idx][mask] += mask_vals[mask]
+
+    def add_range(self, x_coords, y_coords, val):
+        """
+        Dynamically adds a value to all elements within an N-dimensional bounding box.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices (lower bounds).
+            y_coords (iterable of int): 0-based ending indices (inclusive upper bounds).
+            val (int or float): The value to add to the specified volume.
+        """
+        for mask in range(self.num_masks):
+            p_coords = [0] * self.n
+            sign = 1
+            valid = True
+
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = y_coords[d] + 1
+                    if c >= self.dims[d]:
+                        valid = False
+                        break
+                    p_coords[d] = c
+                    sign = -sign
+                else:
+                    p_coords[d] = x_coords[d]
+
+            if valid:
+                self._add_point(p_coords, sign * val)
+
+    def query_prefix(self, coords):
+        """
+        Calculates the spatial volume from the origin up to the given coordinates
+        using the 2^N algebraic expansion.
+        """
+        clamped_coords = [min(coords[d], self.dims[d] - 1) for d in range(self.n)]
+
+        dim_indices = []
+        for d in range(self.n):
+            idx_list = []
+            i = clamped_coords[d] + 1
+            while i > 0:
+                idx_list.append((i - 1) * self.strides[d])
+                i -= i & (-i)
+            dim_indices.append(idx_list)
+
+        tree_sums = [0] * self.num_masks
+        for offsets in itertools.product(*dim_indices):
+            idx = sum(offsets)
+            for mask in range(self.num_masks):
+                tree_sums[mask] += self.arr[idx][mask]
+
+        res = 0
+        for mask in range(self.num_masks):
+            multiplier = 1
+            for d in range(self.n):
+                if not ((mask >> d) & 1):
+                    multiplier *= clamped_coords[d] + 2
+            res += multiplier * tree_sums[mask]
+
+        return res
+
+    def query_range(self, x_coords, y_coords):
+        """
+        Calculates the dynamic sum of all elements within an N-dimensional bounding box.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices.
+            y_coords (iterable of int): 0-based ending indices (inclusive).
+
+        Returns:
+            int or float: The dynamic sum within the specified volume.
+        """
+        ans = 0
+        for mask in range(self.num_masks):
+            q_coords = [0] * self.n
+            sign = 1
+            valid = True
+
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = x_coords[d] - 1
+                    if c < 0:
+                        valid = False
+                        break
+                    q_coords[d] = c
+                    sign = -sign
+                else:
+                    q_coords[d] = y_coords[d]
+
+            if valid:
+                ans += sign * self.query_prefix(q_coords)
+
+        return ans

ndim_ds-0.1.0/src/dynamic_n_dim_seg_tree.py

@@ -0,0 +1,106 @@
+import itertools
+
+
+class DynamicNDimSegTree:
+    def __init__(self, dims, func=min, default=float("inf")):
+        """
+        Initializes an N-dimensional Iterative Segment Tree.
+        Perfect for dynamic idempotent operations (Min, Max, GCD).
+
+        The grid uses 0-based indexing. It leverages an iterative array layout
+        to strictly bound memory to exactly 2^N * D_1 * D_2 ... * D_n.
+
+        Args:
+            dims (iterable of int): The strict maximum size of the grid in each dimension.
+            func (callable): The function to merge two nodes (e.g., min, max, math.gcd).
+            default (int or float): The identity value for the function.
+        """
+        self.n = len(dims)
+        self.dims = tuple(dims)
+        self.func = func
+        self.default = default
+
+        self.sizes = tuple(2 * d for d in dims)
+
+        self.strides = [1] * self.n
+        for i in range(self.n - 2, -1, -1):
+            self.strides[i] = self.strides[i + 1] * self.sizes[i + 1]
+
+        self.total_size = self.strides[0] * self.sizes[0]
+        self.arr = [self.default] * self.total_size
+
+    def update(self, coords, val):
+        """
+        Updates a specific point and iteratively recomputes the affected tree hierarchy.
+
+        Args:
+            coords (iterable of int): 0-based coordinate indices of the point.
+            val (int or float): The new value for the specified point.
+        """
+        leaf_coords = [coords[d] + self.dims[d] for d in range(self.n)]
+
+        paths = []
+        for d in range(self.n):
+            path = []
+            p = leaf_coords[d]
+            while p >= 1:
+                path.append(p)
+                p >>= 1
+            paths.append(path)
+
+        for p_tuple in itertools.product(*paths):
+            idx = 0
+            for d in range(self.n):
+                idx += p_tuple[d] * self.strides[d]
+
+            split_dim = -1
+            for d in range(self.n):
+                if p_tuple[d] != leaf_coords[d]:
+                    split_dim = d
+                    break
+
+            if split_dim == -1:
+                self.arr[idx] = val
+            else:
+                left_idx = idx + p_tuple[split_dim] * self.strides[split_dim]
+                right_idx = left_idx + self.strides[split_dim]
+                self.arr[idx] = self.func(self.arr[left_idx], self.arr[right_idx])
+
+    def query_range(self, x_coords, y_coords):
+        """
+        Iteratively calculates the aggregate function over an N-dimensional bounding box.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices (lower bounds).
+            y_coords (iterable of int): 0-based ending indices (inclusive upper bounds).
+
+        Returns:
+            int or float: The aggregated result (e.g., minimum value) in the volume.
+        """
+        dim_nodes = []
+
+        for d in range(self.n):
+            if x_coords[d] > y_coords[d]:
+                return self.default
+
+            left_idx = x_coords[d] + self.dims[d]
+            r = y_coords[d] + self.dims[d] + 1
+            nodes = []
+
+            while left_idx < r:
+                if left_idx % 2 == 1:
+                    nodes.append(left_idx * self.strides[d])
+                    left_idx += 1
+                if r % 2 == 1:
+                    r -= 1
+                    nodes.append(r * self.strides[d])
+                left_idx >>= 1
+                r >>= 1
+
+            dim_nodes.append(nodes)
+
+        res = self.default
+        for offsets in itertools.product(*dim_nodes):
+            res = self.func(res, self.arr[sum(offsets)])
+
+        return res

ndim_ds-0.1.0/src/ndim_ds.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: ndim_ds
+Version: 0.1.0
+Summary: A collection of optimized N-dimensional data structures in Python
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# N-Dimensional Data Structures
+
+A blazing-fast, polyglot (Python & C++) library providing generalized $N$-dimensional data structures. 
+
+Whether you are working in Python for data science and backend engineering, or you need highly-optimized header-only C++ templates to copy-paste into competitive programming platforms like Codeforces and LeetCode, this repository has you covered.
+
+## Data Structures Included
+All structures support $O(1)$ or $O(\log^N(V))$ operations scaled effortlessly across any arbitrary number of dimensions.
+
+1. **Static N-Dim Prefix Sum** (`static_n_dim_prefix_sum`)
+2. **Static N-Dim Difference Array** (`static_n_dim_difference_array`)
+3. **Dynamic N-Dim Fenwick Tree** (`dynamic_n_dim_fenwick_tree`)
+4. **Dynamic N-Dim Difference Fenwick Tree** (`dynamic_n_dim_diff_fenwick_tree`)
+5. **Dynamic N-Dim Range Fenwick Tree** (`dynamic_n_dim_range_fenwick_tree`)
+6. **Dynamic N-Dim Segment Tree** (`dynamic_n_dim_seg_tree`)
+
+---
+
+## C++ (Competitive Programming)
+
+The `cpp/include/ndim/` directory contains highly optimized, header-only C++17 templates designed specifically for **competitive programming**.
+
+They use standard `<bits/stdc++.h>` format with `using namespace std;` to ensure they are instantly copy-pasteable into online judges without causing scope or header errors. Memory is maintained via flat, contiguous 1D vectors mapped algebraically to $N$ dimensions, preventing memory scattering and ensuring maximum CPU cache efficiency.
+
+### Example Usage
+```cpp
+#include "dynamic_n_dim_seg_tree.hpp"
+
+// Example: 3D Segment Tree using std::min
+auto min_func = [](int64_t a, int64_t b) { return min(a, b); };
+int64_t def = 1e18; // infinity
+
+// 4x4x4 grid
+DynamicNDimSegTree<int64_t, decltype(min_func)> tree({4, 4, 4}, min_func, def);
+
+tree.update({1, 1, 1}, 5);
+tree.update({2, 2, 2}, 10);
+
+int64_t val = tree.query_range({0, 0, 0}, {3, 3, 3}); // 5
+```
+
+---
+
+## Python (Data Science / General)
+
+The `python/src/` directory contains the pure-Python implementations. They use 1D list-flattening mathematics similar to numpy under the hood, but operate purely on standard library primitives, ensuring maximum portability without heavy C-extension dependencies.
+
+### Installation
+The library is configured using `uv` via `pyproject.toml`.
+```bash
+cd python
+uv sync
+```
+
+### Example Usage
+```python
+from dynamic_n_dim_range_fenwick_tree import DynamicNDimRangeFenwickTree
+
+# 10x10x10 grid
+tree = DynamicNDimRangeFenwickTree([10, 10, 10])
+
+# Add 50 to the bounding box from (1, 1, 1) to (5, 5, 5)
+tree.add_range([1, 1, 1], [5, 5, 5], 50)
+
+# Query the volume sum from (0, 0, 0) to (3, 3, 3)
+total = tree.query_range([0, 0, 0], [3, 3, 3])
+```
+
+## Testing
+
+Both ecosystems are rigorously tested with aggressive $10^3$ iteration stress tests across $5$-dimensional constraints.
+- **Python**: Uses `pytest`. Run `uv run pytest test/`
+- **C++**: Uses `doctest`. Compile the files in `cpp/test/` using `g++ -std=c++17` and run the resulting executables.

ndim_ds-0.1.0/src/ndim_ds.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/__init__.py
+src/dynamic_n_dim_diff_fenwick_tree.py
+src/dynamic_n_dim_fenwick_tree.py
+src/dynamic_n_dim_range_fenwick_tree.py
+src/dynamic_n_dim_seg_tree.py
+src/static_n_dim_difference_array.py
+src/static_n_dim_prefix_sum.py
+src/ndim_ds.egg-info/PKG-INFO
+src/ndim_ds.egg-info/SOURCES.txt
+src/ndim_ds.egg-info/dependency_links.txt
+src/ndim_ds.egg-info/top_level.txt
+test/test_dynamic_diff_fenwick.py
+test/test_dynamic_fenwick_tree.py
+test/test_dynamic_range_fenwick.py
+test/test_dynamic_seg_tree.py
+test/test_static_difference_array.py
+test/test_static_prefix_sum.py

ndim_ds-0.1.0/src/ndim_ds.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ndim_ds-0.1.0/src/ndim_ds.egg-info/top_level.txt

@@ -0,0 +1,7 @@
+__init__
+dynamic_n_dim_diff_fenwick_tree
+dynamic_n_dim_fenwick_tree
+dynamic_n_dim_range_fenwick_tree
+dynamic_n_dim_seg_tree
+static_n_dim_difference_array
+static_n_dim_prefix_sum

ndim_ds-0.1.0/src/static_n_dim_difference_array.py

@@ -0,0 +1,101 @@
+class StaticNDimDifferenceArray:
+    def __init__(self, dims):
+        """
+        Initializes an N-dimensional grid of zeros with the specified dimensions.
+
+        Args:
+            dims (iterable of int): The size of the grid in each dimension.
+        """
+        self.n = len(dims)
+        self.dims = tuple(dims)
+
+        self.strides = [1] * self.n
+        for i in range(self.n - 2, -1, -1):
+            self.strides[i] = self.strides[i + 1] * self.dims[i + 1]
+
+        self.total_size = self.strides[0] * self.dims[0]
+        self.arr = [0] * self.total_size
+        self.is_swept = False
+
+    def add_range(self, x_coords, y_coords, val):
+        """
+        Adds a value to all elements within an N-dimensional bounding box.
+        This operation is deferred and will not be queryable until sweep() is called.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices of the bounding box
+                for each dimension.
+            y_coords (iterable of int): 0-based ending indices (inclusive) of the bounding box.
+            val (int or float): The value to add to the specified range.
+        """
+        if self.is_swept:
+            raise RuntimeError("Cannot add after sweep.")
+
+        for mask in range(1 << self.n):
+            idx = 0
+            sign = 1
+            valid = True
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = y_coords[d] + 1
+                    if c >= self.dims[d]:
+                        valid = False
+                        break
+                    idx += c * self.strides[d]
+                    sign = -sign
+                else:
+                    c = x_coords[d]
+                    idx += c * self.strides[d]
+
+            if valid:
+                self.arr[idx] += sign * val
+
+    def sweep(self):
+        """
+        Processes all accumulated range updates and prepares the grid for range queries.
+        This transitions the data structure from an update phase to a query phase.
+        Must be called exactly once after all additions and before any queries.
+        """
+        for _ in range(2):
+            for d in range(self.n):
+                stride = self.strides[d]
+                dim_size = self.dims[d]
+                for i in range(self.total_size):
+                    if (i // stride) % dim_size > 0:
+                        self.arr[i] += self.arr[i - stride]
+        self.is_swept = True
+
+    def query_range(self, x_coords, y_coords):
+        """
+        Calculates the sum of all elements within an N-dimensional bounding box.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices of the bounding box.
+            y_coords (iterable of int): 0-based ending indices (inclusive) of the bounding box.
+
+        Returns:
+            int or float: The sum of the elements in the specified range.
+        """
+        if not self.is_swept:
+            raise RuntimeError("Must sweep before query.")
+
+        ans = 0
+        for mask in range(1 << self.n):
+            idx = 0
+            sign = 1
+            valid = True
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = x_coords[d] - 1
+                    if c < 0:
+                        valid = False
+                        break
+                    idx += c * self.strides[d]
+                    sign = -sign
+                else:
+                    c = y_coords[d]
+                    idx += c * self.strides[d]
+
+            if valid:
+                ans += sign * self.arr[idx]
+        return ans

ndim_ds-0.1.0/src/static_n_dim_prefix_sum.py

@@ -0,0 +1,98 @@
+class StaticNDimPrefixSum:
+    def __init__(self, dims):
+        """
+        Initializes an N-dimensional grid optimized for offline point updates
+        followed by rapid range queries using a static prefix sum array.
+
+        The grid uses 0-based indexing and allocates memory strictly for the requested
+        dimensions, ensuring no wasted padding space.
+
+        Args:
+            dims (iterable of int): The strict maximum size of the grid in each dimension.
+                                    For example, dims=[5, 5] allows coordinates from (0,0) to (4,4).
+        """
+        self.n = len(dims)
+        self.dims = tuple(dims)
+
+        self.strides = [1] * self.n
+        for i in range(self.n - 2, -1, -1):
+            self.strides[i] = self.strides[i + 1] * self.dims[i + 1]
+
+        self.total_size = self.strides[0] * self.dims[0]
+        self.arr = [0] * self.total_size
+        self.is_swept = False
+
+    def add(self, coords, val):
+        """
+        Adds a value to a specific point in the grid.
+        This operation is deferred; the true prefix sum must be built by calling sweep()
+        before any range queries can be made.
+
+        Args:
+            coords (iterable of int): 0-based coordinate indices of the point.
+            val (int or float): The value to add to the specified point.
+        """
+        if self.is_swept:
+            raise RuntimeError("Cannot add points after the grid has been swept.")
+
+        idx = 0
+        for d in range(self.n):
+            idx += coords[d] * self.strides[d]
+
+        self.arr[idx] += val
+
+    def sweep(self):
+        """
+        Processes all accumulated point updates and computes the N-dimensional prefix sum.
+        This transitions the data structure from an update phase to a query phase.
+        Must be called exactly once after all additions and before any queries.
+        """
+        for d in range(self.n):
+            stride = self.strides[d]
+            dim_size = self.dims[d]
+            for i in range(self.total_size):
+                if (i // stride) % dim_size > 0:
+                    self.arr[i] += self.arr[i - stride]
+
+        self.is_swept = True
+
+    def query_range(self, x_coords, y_coords):
+        """
+        Calculates the exact sum of all elements within an N-dimensional bounding box.
+        Uses the Inclusion-Exclusion principle over the $2^N$ vertices of the hyper-rectangle.
+
+        Args:
+            x_coords (iterable of int): 0-based starting indices (lower bounds)
+                of the bounding box.
+            y_coords (iterable of int): 0-based ending indices (inclusive upper bounds)
+                of the bounding box.
+
+        Returns:
+            int or float: The sum of the elements within the specified bounding box.
+        """
+        if not self.is_swept:
+            raise RuntimeError("Must call sweep() before querying.")
+
+        ans = 0
+        for mask in range(1 << self.n):
+            idx = 0
+            sign = 1
+            valid = True
+
+            for d in range(self.n):
+                if (mask >> d) & 1:
+                    c = x_coords[d] - 1
+
+                    if c < 0:
+                        valid = False
+                        break
+                    idx += c * self.strides[d]
+                    sign = -sign
+                else:
+                    c = y_coords[d]
+                    idx += c * self.strides[d]
+
+            if valid:
+                ans += sign * self.arr[idx]
+
+        return ans

ndim_ds-0.1.0/test/test_dynamic_diff_fenwick.py

@@ -0,0 +1,51 @@
+import itertools
+import random
+
+from dynamic_n_dim_diff_fenwick_tree import DynamicNDimDiffFenwickTree
+
+
+def test_dynamic_diff_fenwick_2d():
+    tree = DynamicNDimDiffFenwickTree([5, 5])
+    tree.add_range([1, 1], [2, 2], 5)
+    assert tree.query_point([0, 0]) == 0
+    assert tree.query_point([1, 1]) == 5
+    assert tree.query_point([2, 2]) == 5
+    assert tree.query_point([3, 3]) == 0
+    assert tree.query_point([1, 2]) == 5
+    tree.add_range([2, 2], [3, 3], 10)
+    assert tree.query_point([1, 1]) == 5
+    assert tree.query_point([2, 2]) == 15
+    assert tree.query_point([3, 3]) == 10
+    assert tree.query_point([4, 4]) == 0
+
+
+def test_dynamic_diff_fenwick_3d():
+    tree = DynamicNDimDiffFenwickTree([4, 4, 4])
+    tree.add_range([0, 0, 0], [2, 2, 2], 100)
+    assert tree.query_point([0, 0, 0]) == 100
+    assert tree.query_point([2, 2, 2]) == 100
+    assert tree.query_point([3, 3, 3]) == 0
+
+
+def test_dynamic_diff_fenwick_stress():
+    """Stress test with 5 dimensions (4x4x4x4x4 = 1024) and 1000 calls."""
+    dims = [4, 4, 4, 4, 4]
+    tree = DynamicNDimDiffFenwickTree(dims)
+    grid_bf = {}
+
+    random.seed(42)
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+        val = random.randint(1, 100)
+        tree.add_range(x_coords, y_coords, val)
+
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            grid_bf[c] = grid_bf.get(c, 0) + val
+
+    for _ in range(1000):
+        coords = [random.randint(0, d - 1) for d in dims]
+        expected = grid_bf.get(tuple(coords), 0)
+        assert tree.query_point(coords) == expected

ndim_ds-0.1.0/test/test_dynamic_fenwick_tree.py

@@ -0,0 +1,56 @@
+import itertools
+import random
+
+from dynamic_n_dim_fenwick_tree import DynamicNDimFenwickTree
+
+
+def test_dynamic_fenwick_tree_2d():
+    tree = DynamicNDimFenwickTree([5, 5])
+    tree.add([1, 1], 10)
+    tree.add([2, 2], 5)
+    tree.add([3, 3], 15)
+    assert tree.query_range([1, 1], [1, 1]) == 10
+    assert tree.query_range([0, 0], [2, 2]) == 15
+    assert tree.query_range([1, 1], [4, 4]) == 30
+    assert tree.query_range([2, 2], [3, 3]) == 20
+    assert tree.query_range([0, 0], [0, 0]) == 0
+    tree.add([2, 2], 5)
+    assert tree.query_range([2, 2], [3, 3]) == 25
+
+
+def test_dynamic_fenwick_tree_3d():
+    tree = DynamicNDimFenwickTree([3, 3, 3])
+    tree.add([0, 0, 0], 1)
+    tree.add([1, 1, 1], 2)
+    tree.add([2, 2, 2], 3)
+    assert tree.query_range([0, 0, 0], [2, 2, 2]) == 6
+    assert tree.query_range([0, 0, 0], [1, 1, 1]) == 3
+    assert tree.query_range([1, 1, 1], [2, 2, 2]) == 5
+    assert tree.query_prefix([2, 2, 2]) == 6
+
+
+def test_dynamic_fenwick_tree_stress():
+    """Stress test with 5 dimensions (4x4x4x4x4 = 1024) and 1000 calls."""
+    dims = [4, 4, 4, 4, 4]
+    tree = DynamicNDimFenwickTree(dims)
+    grid_bf = {}
+
+    random.seed(42)
+
+    for _ in range(1000):
+        coords = [random.randint(0, d - 1) for d in dims]
+        val = random.randint(1, 100)
+        tree.add(coords, val)
+        c_tuple = tuple(coords)
+        grid_bf[c_tuple] = grid_bf.get(c_tuple, 0) + val
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+
+        expected = 0
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            expected += grid_bf.get(c, 0)
+
+        assert tree.query_range(x_coords, y_coords) == expected

ndim_ds-0.1.0/test/test_dynamic_range_fenwick.py

@@ -0,0 +1,55 @@
+import itertools
+import random
+
+from dynamic_n_dim_range_fenwick_tree import DynamicNDimRangeFenwickTree
+
+
+def test_dynamic_range_fenwick_2d():
+    tree = DynamicNDimRangeFenwickTree([4, 4])
+    tree.add_range([0, 0], [1, 1], 5)
+    assert tree.query_range([0, 0], [0, 0]) == 5
+    assert tree.query_range([1, 1], [1, 1]) == 5
+    assert tree.query_range([0, 0], [1, 1]) == 20
+    assert tree.query_range([0, 0], [3, 3]) == 20
+    tree.add_range([1, 1], [2, 2], 10)
+    assert tree.query_range([1, 1], [1, 1]) == 15
+    assert tree.query_range([0, 0], [3, 3]) == 60
+    assert tree.query_prefix([1, 1]) == 30
+
+
+def test_dynamic_range_fenwick_3d():
+    tree = DynamicNDimRangeFenwickTree([3, 3, 3])
+    tree.add_range([0, 0, 0], [1, 1, 1], 1)
+    assert tree.query_range([0, 0, 0], [0, 0, 0]) == 1
+    assert tree.query_range([0, 0, 0], [1, 1, 1]) == 8
+    assert tree.query_range([0, 0, 0], [2, 2, 2]) == 8
+
+
+def test_dynamic_range_fenwick_stress():
+    """Stress test with 5 dimensions (4x4x4x4x4 = 1024) and 1000 calls."""
+    dims = [4, 4, 4, 4, 4]
+    tree = DynamicNDimRangeFenwickTree(dims)
+    grid_bf = {}
+
+    random.seed(42)
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+        val = random.randint(1, 100)
+        tree.add_range(x_coords, y_coords, val)
+
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            grid_bf[c] = grid_bf.get(c, 0) + val
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+
+        expected = 0
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            expected += grid_bf.get(c, 0)
+
+        assert tree.query_range(x_coords, y_coords) == expected

ndim_ds-0.1.0/test/test_dynamic_seg_tree.py

@@ -0,0 +1,61 @@
+import itertools
+import math
+import random
+
+from dynamic_n_dim_seg_tree import DynamicNDimSegTree
+
+
+def test_dynamic_seg_tree_2d():
+    tree = DynamicNDimSegTree([4, 4], func=min, default=float("inf"))
+    tree.update([0, 0], 10)
+    tree.update([1, 1], 5)
+    tree.update([2, 2], 15)
+    tree.update([3, 3], 20)
+    assert tree.query_range([0, 0], [3, 3]) == 5
+    assert tree.query_range([0, 0], [0, 0]) == 10
+    assert tree.query_range([2, 2], [3, 3]) == 15
+    assert tree.query_range([0, 2], [1, 3]) == float("inf")
+
+
+def test_dynamic_seg_tree_gcd():
+    tree = DynamicNDimSegTree([2, 2], func=math.gcd, default=0)
+    tree.update([0, 0], 24)
+    tree.update([1, 1], 36)
+    assert tree.query_range([0, 0], [1, 1]) == 12
+    assert tree.query_range([0, 0], [0, 0]) == 24
+
+
+def test_dynamic_seg_tree_max():
+    tree = DynamicNDimSegTree([3, 3, 3], func=max, default=float("-inf"))
+    tree.update([0, 0, 0], 100)
+    tree.update([1, 1, 1], 500)
+    tree.update([2, 2, 2], 200)
+    assert tree.query_range([0, 0, 0], [2, 2, 2]) == 500
+    assert tree.query_range([0, 0, 0], [0, 1, 1]) == 100
+
+
+def test_dynamic_seg_tree_stress():
+    """Stress test with 5 dimensions (4x4x4x4x4 = 1024) and 1000 calls."""
+    dims = [4, 4, 4, 4, 4]
+    tree = DynamicNDimSegTree(dims, func=min, default=float("inf"))
+    grid_bf = {}
+
+    random.seed(42)
+
+    for _ in range(1000):
+        coords = [random.randint(0, d - 1) for d in dims]
+        val = random.randint(1, 1000)
+        tree.update(coords, val)
+        c_tuple = tuple(coords)
+        grid_bf[c_tuple] = val
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+
+        expected = float("inf")
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            expected = min(expected, grid_bf.get(c, float("inf")))
+
+        assert tree.query_range(x_coords, y_coords) == expected

ndim_ds-0.1.0/test/test_static_difference_array.py

@@ -0,0 +1,69 @@
+import itertools
+import random
+
+import pytest
+from static_n_dim_difference_array import StaticNDimDifferenceArray
+
+
+def test_static_difference_array_2d():
+    grid = StaticNDimDifferenceArray([4, 4])
+    grid.add_range([1, 1], [2, 2], 5)
+    grid.add_range([0, 0], [1, 2], 3)
+    grid.sweep()
+    assert grid.query_range([0, 0], [0, 0]) == 3
+    assert grid.query_range([1, 1], [1, 1]) == 8
+    assert grid.query_range([2, 2], [2, 2]) == 5
+    assert grid.query_range([3, 3], [3, 3]) == 0
+    assert grid.query_range([1, 1], [2, 2]) == 26
+
+
+def test_static_difference_array_3d():
+    grid = StaticNDimDifferenceArray([3, 3, 3])
+    grid.add_range([0, 0, 0], [1, 1, 1], 10)
+    grid.sweep()
+    assert grid.query_range([0, 0, 0], [0, 0, 0]) == 10
+    assert grid.query_range([1, 1, 1], [1, 1, 1]) == 10
+    assert grid.query_range([2, 2, 2], [2, 2, 2]) == 0
+    assert grid.query_range([0, 0, 0], [1, 1, 1]) == 80
+
+
+def test_static_difference_array_errors():
+    grid = StaticNDimDifferenceArray([2, 2])
+    grid.add_range([0, 0], [1, 1], 1)
+    with pytest.raises(RuntimeError):
+        grid.query_range([0, 0], [1, 1])
+    grid.sweep()
+    with pytest.raises(RuntimeError):
+        grid.add_range([0, 0], [0, 0], 5)
+
+
+def test_static_difference_array_stress():
+    """Stress test with 5 dimensions (4x4x4x4x4 = 1024) and 1000 calls."""
+    dims = [4, 4, 4, 4, 4]
+    grid = StaticNDimDifferenceArray(dims)
+    grid_bf = {}
+
+    random.seed(42)
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+        val = random.randint(1, 100)
+        grid.add_range(x_coords, y_coords, val)
+
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            grid_bf[c] = grid_bf.get(c, 0) + val
+
+    grid.sweep()
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+
+        expected = 0
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            expected += grid_bf.get(c, 0)
+
+        assert grid.query_range(x_coords, y_coords) == expected

ndim_ds-0.1.0/test/test_static_prefix_sum.py

@@ -0,0 +1,68 @@
+import itertools
+import random
+
+import pytest
+from static_n_dim_prefix_sum import StaticNDimPrefixSum
+
+
+def test_static_prefix_sum_2d():
+    grid = StaticNDimPrefixSum([3, 3])
+    grid.add([0, 0], 1)
+    grid.add([1, 1], 2)
+    grid.add([2, 2], 3)
+    grid.sweep()
+    assert grid.query_range([0, 0], [0, 0]) == 1
+    assert grid.query_range([1, 1], [1, 1]) == 2
+    assert grid.query_range([2, 2], [2, 2]) == 3
+    assert grid.query_range([0, 0], [2, 2]) == 6
+    assert grid.query_range([0, 0], [1, 1]) == 3
+    assert grid.query_range([0, 0], [0, 1]) == 1
+
+
+def test_static_prefix_sum_3d():
+    grid = StaticNDimPrefixSum([2, 2, 2])
+    grid.add([0, 0, 0], 5)
+    grid.add([1, 1, 1], 10)
+    grid.sweep()
+    assert grid.query_range([0, 0, 0], [1, 1, 1]) == 15
+    assert grid.query_range([0, 0, 0], [0, 1, 1]) == 5
+    assert grid.query_range([1, 1, 1], [1, 1, 1]) == 10
+
+
+def test_static_prefix_sum_errors():
+    grid = StaticNDimPrefixSum([2, 2])
+    grid.add([0, 0], 1)
+    with pytest.raises(RuntimeError):
+        grid.query_range([0, 0], [1, 1])
+    grid.sweep()
+    with pytest.raises(RuntimeError):
+        grid.add([1, 1], 5)
+
+
+def test_static_prefix_sum_stress():
+    """Stress test with 5 dimensions (4x4x4x4x4 = 1024) and 1000 calls."""
+    dims = [4, 4, 4, 4, 4]
+    grid = StaticNDimPrefixSum(dims)
+    grid_bf = {}
+
+    random.seed(42)
+
+    for _ in range(1000):
+        coords = [random.randint(0, d - 1) for d in dims]
+        val = random.randint(1, 100)
+        grid.add(coords, val)
+        c_tuple = tuple(coords)
+        grid_bf[c_tuple] = grid_bf.get(c_tuple, 0) + val
+
+    grid.sweep()
+
+    for _ in range(1000):
+        x_coords = [random.randint(0, d - 1) for d in dims]
+        y_coords = [random.randint(x, d - 1) for x, d in zip(x_coords, dims)]
+
+        expected = 0
+        ranges = [range(x, y + 1) for x, y in zip(x_coords, y_coords)]
+        for c in itertools.product(*ranges):
+            expected += grid_bf.get(c, 0)
+
+        assert grid.query_range(x_coords, y_coords) == expected