0.29.21

sampling update

Author: bartzbeielstein

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.29.20"
+version = "0.29.21"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotpython/utils/sampling.py

@@ -951,3 +951,44 @@ def mmphi_intensive(X: np.ndarray, q: Optional[float] = 2.0, p: Optional[float]
         return np.inf
 
     return intensive_phiq
+
+
+def mmphi_intensive_update(X: np.ndarray, new_point: np.ndarray, J: np.ndarray, d: np.ndarray, q: float = 2.0, p: float = 2.0) -> tuple[float, np.ndarray, np.ndarray]:
+    """
+    Updates the Morris-Mitchell intensive criterion for n+1 points by adding a new point to the design.
+
+    Args:
+        X (np.ndarray): Existing sampling plan (shape: (n, d)).
+        new_point (np.ndarray): New point to add (shape: (d,)).
+        J (np.ndarray): Multiplicities of distances for the existing design.
+        d (np.ndarray): Unique distances for the existing design.
+        q (float): Exponent used in the computation of the metric. Defaults to 2.0.
+        p (float): Distance norm to use (e.g., p=1 for Manhattan, p=2 for Euclidean). Defaults to 2.0.
+
+    Returns:
+        tuple[float, np.ndarray, np.ndarray]: Updated intensive_phiq, updated_J, updated_d.
+    """
+    n_points = X.shape[0]
+    if n_points < 1:
+        raise ValueError("The existing design must contain at least one point.")
+
+    # Compute distances between the new point and all existing points
+    new_distances = np.array([np.linalg.norm(new_point - X[i], ord=p) for i in range(n_points)])
+
+    # Combine old distances and new distances into a single list
+    all_distances = []
+    for dist, count in zip(d, J):
+        all_distances.extend([dist] * count)
+    all_distances.extend(new_distances)
+
+    # Find unique distances and their counts
+    updated_d, updated_J = np.unique(all_distances, return_counts=True)
+
+    # Calculate the number of unique pairs of points
+    M = (n_points + 1) * n_points / 2
+
+    # Compute the updated intensive_phiq
+    sum_term = np.sum(updated_J * (updated_d ** (-q)))
+    intensive_phiq = (sum_term / M) ** (1.0 / q)
+
+    return intensive_phiq, updated_J, updated_d

test/test_sampling_mmphi_update.py

@@ -0,0 +1,86 @@
+import numpy as np
+import pytest
+from spotpython.utils.sampling import mmphi_intensive_update
+
+def test_mmphi_intensive_update_basic():
+    # 2 points in 2D
+    X = np.array([[0.0, 0.0], [1.0, 0.0]])
+    new_point = np.array([0.0, 1.0])
+    # Initial distances and multiplicities (only one pair: distance 1.0)
+    d = np.array([1.0])
+    J = np.array([1])
+    q = 2.0
+    p = 2.0
+
+    intensive_phiq, updated_J, updated_d = mmphi_intensive_update(X, new_point, J, d, q, p)
+
+    # There are now 3 points, so 3 pairs: (0,1), (0,2), (1,2)
+    # Distances: (0,1): 1.0, (0,2): 1.0, (1,2): sqrt(2)
+    expected_d = np.array([1.0, np.sqrt(2)])
+    expected_J = np.array([2, 1])
+    assert np.allclose(np.sort(updated_d), np.sort(expected_d))
+    assert np.sum(updated_J) == 3  # 3 pairs
+
+    # Check the value is finite and positive
+    assert intensive_phiq > 0
+    assert np.isfinite(intensive_phiq)
+
+def test_mmphi_intensive_update_single_point_raises():
+    X = np.empty((0, 2))
+    new_point = np.array([0.0, 0.0])
+    d = np.array([])
+    J = np.array([])
+    with pytest.raises(ValueError):
+        mmphi_intensive_update(X, new_point, J, d)
+
+def test_mmphi_intensive_update_duplicate_distances():
+    """
+    Test mmphi_intensive_update with duplicate distances.
+    """
+    X = np.array([[0.0], [1.0], [2.0]])
+    new_point = np.array([3.0])
+    d = np.array([1.0, 2.0])
+    J = np.array([2, 1])
+    q = 2.0
+    p = 2.0
+
+    intensive_phiq, updated_J, updated_d = mmphi_intensive_update(X, new_point, J, d, q, p)
+
+    # Expected distances and counts
+    expected_d = np.array([1.0, 2.0, 3.0])
+    expected_J = np.array([3, 2, 1])
+
+    assert np.allclose(np.sort(updated_d), np.sort(expected_d))
+    assert np.array_equal(updated_J, expected_J)
+    assert np.sum(updated_J) == 6  # 4 points, 6 pairs
+
+    # Check the value is finite and positive
+    assert intensive_phiq > 0
+    assert np.isfinite(intensive_phiq)
+
+def test_mmphi_intensive_update_nondefault_q_p():
+    """
+    Test mmphi_intensive_update with non-default values of q and p.
+    """
+    X = np.array([[0.0, 0.0], [1.0, 1.0]])
+    new_point = np.array([0.0, 2.0])
+    d = np.array([np.sqrt(2)])  # Existing distances should remain unchanged
+    J = np.array([1])           # Existing counts should remain unchanged
+    q = 1.0
+    p = 1.0
+
+    intensive_phiq, updated_J, updated_d = mmphi_intensive_update(X, new_point, J, d, q, p)
+
+    # Expected distances and counts
+    # Combine original distances with new distances calculated using Manhattan distance
+    new_distances = np.array([np.sum(np.abs(X[0] - new_point)), np.sum(np.abs(X[1] - new_point))])
+    all_distances = np.concatenate((d, new_distances))
+    expected_d, expected_J = np.unique(all_distances, return_counts=True)
+
+    assert np.allclose(np.sort(updated_d), np.sort(expected_d))
+    assert np.array_equal(updated_J, expected_J)
+    assert np.sum(updated_J) == len(all_distances)  # Total number of pairs
+
+    # Check the value is finite and positive
+    assert intensive_phiq > 0
+    assert np.isfinite(intensive_phiq)