add engineering based test functions

Author: SimonBlanke

src/surfaces/test_functions/__init__.py

@@ -8,8 +8,18 @@
 from .machine_learning import machine_learning_functions
 from .machine_learning import *  # noqa: F401,F403
 
+from .engineering import *  # noqa: F401,F403
+
+# Engineering function list
+engineering_functions = [
+    "ThreeBarTrussFunction",
+    "WeldedBeamFunction",
+    "PressureVesselFunction",
+    "TensionCompressionSpringFunction",
+    "CantileverBeamFunction",
+]
 
 # Backwards compatibility alias
 mathematical_functions = algebraic_functions
 
-test_functions: list = algebraic_functions + machine_learning_functions
+test_functions: list = algebraic_functions + machine_learning_functions + engineering_functions

src/surfaces/test_functions/engineering/__init__.py

@@ -0,0 +1,74 @@
+# Author: Simon Blanke
+# Email: simon.blanke@yahoo.com
+# License: MIT License
+
+"""Engineering design optimization benchmark functions.
+
+This module provides a collection of classic engineering design optimization
+problems. These are real-world inspired benchmarks with physical meaning,
+commonly used to evaluate constrained optimization algorithms.
+
+All problems are formulated as minimization with constraints handled via
+penalty methods. Each function provides:
+
+- `raw_objective(params)`: The pure engineering objective (cost, weight, etc.)
+- `constraints(params)`: Constraint function values (g <= 0 is feasible)
+- `constraint_violations(params)`: Positive violation amounts
+- `is_feasible(params)`: Boolean feasibility check
+- `penalty(params)`: Total penalty for constraint violations
+
+The default `__call__` method returns the penalized objective:
+f(x) + penalty_coefficient * sum(max(0, g_i(x))^2)
+
+Available Functions
+-------------------
+Structural Engineering:
+    ThreeBarTrussFunction : 2D, 3 constraints
+        Minimize weight of a symmetric truss structure.
+    CantileverBeamFunction : 5D, 1 constraint
+        Minimize weight of a stepped cantilever beam.
+
+Manufacturing/Mechanical:
+    WeldedBeamFunction : 4D, 5 constraints
+        Minimize fabrication cost of a welded beam joint.
+    PressureVesselFunction : 4D, 3 constraints
+        Minimize cost of a cylindrical pressure vessel.
+    TensionCompressionSpringFunction : 3D, 4 constraints
+        Minimize weight of a helical compression spring.
+
+Examples
+--------
+>>> from surfaces.test_functions.engineering import WeldedBeamFunction
+>>> func = WeldedBeamFunction()
+>>> # Evaluate with penalty
+>>> cost = func({"h": 0.2, "l": 3.5, "t": 9.0, "b": 0.2})
+>>> # Check raw objective without penalty
+>>> raw_cost = func.raw_objective({"h": 0.2, "l": 3.5, "t": 9.0, "b": 0.2})
+>>> # Check if solution is feasible
+>>> func.is_feasible({"h": 0.2, "l": 3.5, "t": 9.0, "b": 0.2})
+
+References
+----------
+Most problems originate from:
+
+.. [1] Coello, C.A.C. (2000). "Use of a self-adaptive penalty approach
+       for engineering optimization problems."
+.. [2] Deb, K. (2000). "An efficient constraint handling method for
+       genetic algorithms."
+"""
+
+from ._base_engineering_function import EngineeringFunction
+from .three_bar_truss import ThreeBarTrussFunction
+from .welded_beam import WeldedBeamFunction
+from .pressure_vessel import PressureVesselFunction
+from .tension_compression_spring import TensionCompressionSpringFunction
+from .cantilever_beam import CantileverBeamFunction
+
+__all__ = [
+    "EngineeringFunction",
+    "ThreeBarTrussFunction",
+    "WeldedBeamFunction",
+    "PressureVesselFunction",
+    "TensionCompressionSpringFunction",
+    "CantileverBeamFunction",
+]

src/surfaces/test_functions/engineering/_base_engineering_function.py

@@ -0,0 +1,190 @@
+# Author: Simon Blanke
+# Email: simon.blanke@yahoo.com
+# License: MIT License
+
+"""Base class for engineering design optimization test functions."""
+
+import numpy as np
+from typing import Dict, Any, List, Tuple, Union
+
+from .._base_test_function import BaseTestFunction
+
+
+class EngineeringFunction(BaseTestFunction):
+    """Base class for real-world engineering design optimization problems.
+
+    Engineering functions represent practical design optimization problems
+    from domains like structural mechanics, manufacturing, and mechanical
+    engineering. Unlike purely mathematical test functions, these problems
+    have physical meaning and constraints derived from engineering principles.
+
+    Most engineering problems are inherently constrained. This base class
+    provides infrastructure for handling constraints via penalty methods,
+    converting constrained problems into unconstrained ones suitable for
+    general-purpose optimizers.
+
+    Parameters
+    ----------
+    objective : str, default="minimize"
+        Either "minimize" or "maximize".
+    sleep : float, default=0
+        Artificial delay in seconds added to each evaluation.
+    penalty_coefficient : float, default=1e6
+        Coefficient for constraint violation penalties. Higher values
+        enforce constraints more strictly but may create steep gradients.
+
+    Attributes
+    ----------
+    n_dim : int
+        Number of design variables.
+    variable_names : list of str
+        Names of design variables (e.g., ["thickness", "radius"]).
+    variable_bounds : list of tuple
+        Bounds for each variable as (min, max) pairs.
+
+    Notes
+    -----
+    Constraint handling uses the exterior penalty method:
+
+    .. math::
+
+        F(x) = f(x) + r \\sum_{i} \\max(0, g_i(x))^2
+
+    where f(x) is the objective, g_i(x) are inequality constraints
+    (g_i(x) <= 0 is feasible), and r is the penalty coefficient.
+    """
+
+    _spec = {
+        "default_bounds": None,  # Engineering functions have variable-specific bounds
+        "continuous": True,
+        "differentiable": True,
+        "constrained": True,
+    }
+
+    default_size: int = 10000
+
+    # Subclasses should define these
+    variable_names: List[str] = []
+    variable_bounds: List[Tuple[float, float]] = []
+
+    def __init__(
+        self,
+        objective: str = "minimize",
+        sleep: float = 0,
+        penalty_coefficient: float = 1e6
+    ):
+        self.penalty_coefficient = penalty_coefficient
+        super().__init__(objective, sleep)
+
+    @property
+    def n_dim(self) -> int:
+        """Number of design variables."""
+        return len(self.variable_names)
+
+    @property
+    def search_space(self) -> Dict[str, Any]:
+        """Search space based on variable bounds."""
+        search_space_ = {}
+        total_size = self.default_size
+        dim_size = int(total_size ** (1 / self.n_dim))
+
+        for i, (name, (lb, ub)) in enumerate(
+            zip(self.variable_names, self.variable_bounds)
+        ):
+            step_size = (ub - lb) / dim_size
+            values = np.arange(lb, ub, step_size)
+            search_space_[name] = values
+
+        return search_space_
+
+    def _get_values(self, params: Dict[str, Any]) -> np.ndarray:
+        """Extract variable values from params dict in order."""
+        return np.array([params[name] for name in self.variable_names])
+
+    def constraints(self, params: Dict[str, Any]) -> List[float]:
+        """Evaluate constraint functions.
+
+        Override in subclasses to define problem-specific constraints.
+        Each constraint g_i should be formulated such that g_i <= 0 is feasible.
+
+        Parameters
+        ----------
+        params : dict
+            Design variable values.
+
+        Returns
+        -------
+        list of float
+            Constraint function values. Negative or zero means feasible.
+        """
+        return []
+
+    def constraint_violations(self, params: Dict[str, Any]) -> List[float]:
+        """Calculate constraint violations (positive values only).
+
+        Parameters
+        ----------
+        params : dict
+            Design variable values.
+
+        Returns
+        -------
+        list of float
+            Violation amounts. Zero means constraint is satisfied.
+        """
+        return [max(0, g) for g in self.constraints(params)]
+
+    def is_feasible(self, params: Dict[str, Any]) -> bool:
+        """Check if a solution satisfies all constraints.
+
+        Parameters
+        ----------
+        params : dict
+            Design variable values.
+
+        Returns
+        -------
+        bool
+            True if all constraints are satisfied.
+        """
+        return all(g <= 0 for g in self.constraints(params))
+
+    def penalty(self, params: Dict[str, Any]) -> float:
+        """Calculate total penalty for constraint violations.
+
+        Parameters
+        ----------
+        params : dict
+            Design variable values.
+
+        Returns
+        -------
+        float
+            Penalty value (sum of squared violations times coefficient).
+        """
+        violations = self.constraint_violations(params)
+        return self.penalty_coefficient * sum(v ** 2 for v in violations)
+
+    def raw_objective(self, params: Dict[str, Any]) -> float:
+        """Evaluate the raw objective function without penalties.
+
+        Override in subclasses to define the engineering objective.
+
+        Parameters
+        ----------
+        params : dict
+            Design variable values.
+
+        Returns
+        -------
+        float
+            Raw objective function value.
+        """
+        raise NotImplementedError("Subclasses must implement raw_objective")
+
+    def _create_objective_function(self):
+        """Create objective function with penalty for constraint violations."""
+        def penalized_objective(params):
+            return self.raw_objective(params) + self.penalty(params)
+
+        self.pure_objective_function = penalized_objective