Add shekel funcfix

src/surfaces/test_functions/algebraic/__init__.py

@@ -32,7 +32,7 @@
     multi_objective_functions,
 )
 
-# Standard functions (1D, 2D, ND)
+# Standard functions (1D, 2D, 4D, ND)
 from .standard import (
     # 2D
     AckleyFunction,
@@ -60,6 +60,8 @@
     RastriginFunction,
     RosenbrockFunction,
     SchafferFunctionN2,
+    # 4D
+    ShekelFunction,
     SimionescuFunction,
     SineProductFunction,
     SphereFunction,
@@ -68,6 +70,7 @@
     standard_functions,
     standard_functions_1d,
     standard_functions_2d,
+    standard_functions_4d,
     standard_functions_nd,
 )
 
@@ -102,6 +105,8 @@
     "SchafferFunctionN2",
     "SimionescuFunction",
     "ThreeHumpCamelFunction",
+    # Standard 4D
+    "ShekelFunction",
     # Standard ND
     "GriewankFunction",
     "RastriginFunction",
@@ -133,7 +138,9 @@
 mathematical_functions = algebraic_functions
 algebraic_functions_1d = standard_functions_1d
 algebraic_functions_2d = standard_functions_2d
+algebraic_functions_4d = standard_functions_4d
 algebraic_functions_nd = standard_functions_nd
 mathematical_functions_1d = standard_functions_1d
 mathematical_functions_2d = standard_functions_2d
+mathematical_functions_4d = standard_functions_4d
 mathematical_functions_nd = standard_functions_nd

src/surfaces/test_functions/algebraic/standard/__init__.py

@@ -35,6 +35,9 @@
     ThreeHumpCamelFunction,
 )
 
+# 4D functions
+from .test_functions_4d import ShekelFunction
+
 # ND functions
 from .test_functions_nd import (
     GriewankFunction,
@@ -76,6 +79,7 @@
     "RosenbrockFunction",
     "SphereFunction",
     "StyblinskiTangFunction",
+    "ShekelFunction",
 ]
 
 standard_functions = [
@@ -104,6 +108,8 @@
     SchafferFunctionN2,
     SimionescuFunction,
     ThreeHumpCamelFunction,
+    # 4D
+    ShekelFunction,
     # ND
     GriewankFunction,
     RastriginFunction,
@@ -141,6 +147,10 @@
     ThreeHumpCamelFunction,
 ]
 
+standard_functions_4d = [
+    ShekelFunction,
+]
+
 standard_functions_nd = [
     GriewankFunction,
     RastriginFunction,

src/surfaces/test_functions/algebraic/standard/test_functions_4d/__init__.py

@@ -0,0 +1,3 @@
+from .shekel_function import ShekelFunction
+
+__all__ = ["ShekelFunction"]

src/surfaces/test_functions/algebraic/standard/test_functions_4d/shekel_function.py

@@ -0,0 +1,164 @@
+from typing import Any, Callable, Dict, List, Optional, Union
+
+import numpy as np
+
+from surfaces._array_utils import ArrayLike, get_array_namespace
+from surfaces.modifiers import BaseModifier
+
+from ..._base_algebraic_function import AlgebraicFunction
+
+
+class ShekelFunction(AlgebraicFunction):
+    """Shekel 4-dimensional test function.
+
+    A multimodal, non-convex, continuous function fixed at 4 dimensions.
+    It is defined as the sum of m inverse quadratic functions.
+
+    The function is defined as:
+
+    .. math::
+
+        f(\\vec{x}) = - \\sum_{i=1}^{m} \\left( \\sum_{j=1}^{4} (x_j - a_{ij})^2 + c_i \\right)^{-1}
+
+    where :math:`m` is the number of maxima (typically 5, 7, or 10).
+
+    The global minimum is located at :math:`x \\approx (4, 4, 4, 4)` and
+    the value depends on :math:`m`.
+
+    Parameters
+    ----------
+    m : int, default=10
+        Number of maxima. Standard values are 5, 7, or 10.
+    objective : str, default="minimize"
+        Either "minimize" or "maximize".
+    modifiers : list of BaseModifier, optional
+        List of modifiers to apply to function evaluations.
+    memory : bool, default=False
+        Whether to store function evaluations in memory.
+    collect_data : bool, default=True
+        Whether to collect data for visualization/history.
+    callbacks : list of callable, optional
+        Functions to call after evaluation.
+    catch_errors : dict, optional
+        Dictionary mapping error types to return values.
+
+    Attributes
+    ----------
+    n_dim : int
+        Number of dimensions (fixed at 4).
+    default_bounds : tuple
+        Default parameter bounds (0.0, 10.0).
+
+    Examples
+    --------
+    >>> from surfaces.test_functions import ShekelFunction
+    >>> func = ShekelFunction(m=10)
+    >>> result = func({"x0": 4.0, "x1": 4.0, "x2": 4.0, "x3": 4.0})
+    >>> float(result) < -10.0
+    True
+    """
+
+    name = "Shekel Function"
+    _name_ = "shekel_function"
+    __name__ = "ShekelFunction"
+
+    _spec = {
+        "convex": False,
+        "unimodal": False,
+        "separable": False,
+        "scalable": False,
+    }
+
+    f_global = -10.536
+    default_bounds = (0.0, 10.0)
+
+    latex_formula = (
+        r"f(\vec{x}) = - \sum_{i=1}^{m} \left( \sum_{j=1}^{4} (x_j - a_{ij})^2 + c_i \right)^{-1}"
+    )
+    pgfmath_formula = None
+
+    tagline = "A multimodal function with m sharp peaks (Foxholes). " "Fixed 4-dimensional problem."
+    display_bounds = (0.0, 10.0)
+
+    display_projection = {"fixed_values": {"x2": 4.0, "x3": 4.0}}
+
+    reference = "Shekel, J. (1971). Test function for multivariate search problems."
+    reference_url = "https://www.sfu.ca/~ssurjano/shekel.html"
+
+    def __init__(
+        self,
+        m: int = 10,
+        objective: str = "minimize",
+        modifiers: Optional[List[BaseModifier]] = None,
+        memory: bool = False,
+        collect_data: bool = True,
+        callbacks: Optional[Union[Callable, List[Callable]]] = None,
+        catch_errors: Optional[Dict[type, float]] = None,
+    ) -> None:
+        super().__init__(objective, modifiers, memory, collect_data, callbacks, catch_errors)
+
+        self.n_dim = 4
+        self.m = m
+
+        self.A = np.array(
+            [
+                [4.0, 4.0, 4.0, 4.0],
+                [1.0, 1.0, 1.0, 1.0],
+                [8.0, 8.0, 8.0, 8.0],
+                [6.0, 6.0, 6.0, 6.0],
+                [3.0, 7.0, 3.0, 7.0],
+                [2.0, 9.0, 2.0, 9.0],
+                [5.0, 5.0, 3.0, 3.0],
+                [8.0, 1.0, 8.0, 1.0],
+                [6.0, 2.0, 6.0, 2.0],
+                [7.0, 3.6, 7.0, 3.6],
+            ]
+        )
+
+        self.c = np.array([0.1, 0.2, 0.2, 0.4, 0.4, 0.6, 0.3, 0.7, 0.5, 0.5])
+
+        if m < 10:
+            self.A = self.A[:m]
+            self.c = self.c[:m]
+
+        self.x_global = (4.0, 4.0, 4.0, 4.0)
+
+    def _create_objective_function(self) -> None:
+        def shekel_function(params: Dict[str, Any]) -> float:
+            x_input = np.array([params[f"x{i}"] for i in range(self.n_dim)])
+
+            result = 0.0
+            for i in range(self.m):
+                diff = x_input - self.A[i]
+                sq_sum = np.dot(diff, diff)
+                result -= 1.0 / (sq_sum + self.c[i])
+
+            return result
+
+        self.pure_objective_function = shekel_function
+
+    def _batch_objective(self, X: ArrayLike) -> ArrayLike:
+        """Vectorized batch evaluation for Shekel Function."""
+        xp = get_array_namespace(X)
+
+        A = xp.asarray(self.A)
+        c = xp.asarray(self.c)
+
+        n_points = X.shape[0]
+        result = xp.zeros(n_points)
+
+        for i in range(self.m):
+            diff = X - A[i]
+            sq_sum = xp.sum(diff**2, axis=1)
+            result -= 1.0 / (sq_sum + c[i])
+
+        return result
+
+    def _search_space(
+        self,
+        min: float = 0.0,
+        max: float = 10.0,
+        size: int = 10000,
+        value_types: str = "array",
+    ) -> Dict[str, Any]:
+        return super()._create_n_dim_search_space(min, max, size=size, value_types=value_types)