0.29.4

bartzbeielstein · bartzbeielstein · commit 0f0b554f082a · 2025-04-07T22:49:35.000+02:00
diff --git a/notebooks/00_spotPython_tests.ipynb b/notebooks/00_spotPython_tests.ipynb
diff --git a/pyproject.toml b/pyproject.toml
@@ -7,19 +7,18 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.29.3"
+version = "0.29.4"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]
 description = "spotpython - Sequential Parameter Optimization in Python"
 readme = "README.md"
-license = { text="AGPL-3.0-or-later" }
+license = "AGPL-3.0-or-later"
 requires-python = ">=3.10"
 classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
-  "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
   "Operating System :: OS Independent",
 ]
 # PEP 621 dependencies declaration
diff --git a/src/spotpython/fun/objectivefunctions.py b/src/spotpython/fun/objectivefunctions.py
@@ -440,8 +440,9 @@ def fun_runge(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nda
         y = 1 / (1 + sum_squared_diff)
         return self._add_noise(y)
 
-    def fun_wingwt(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
+    def fun_wingwt_to_nat(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
         r"""Wing weight function.
+        Converts coded values to natural values, before applying the original `fun_wingwt` function (Eq. 1.4 in [Forr08a]).
         Calculate the weight of an unpainted light aircraft wing based on design and operational parameters.
         This function implements the wing weight model from Forrester et al., which aims to predict
         the wing weight \( W \) using the following formula:
@@ -477,8 +478,8 @@ def fun_wingwt(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nd
         | \( \lambda \) | Taper ratio                            | 0.672    | 0.5     | 1       |
         | \( R_{tc} \)  | Aerofoil thickness to chord ratio      | 0.12     | 0.08    | 0.18    |
         | \( N_z \)     | Ultimate load factor                   | 3.8      | 2.5     | 6       |
-        | \( W_{dg} \)  | Flight design gross weight (lb)         | 2000     | 1700    | 2500    |
-        | \( W_p \)     | Paint weight \((\text{lb/ft}^2)\)                  | 0.064 |   0.025  | 0.08    |
+        | \( W_{dg} \)  | Flight design gross weight (lb)        | 2000     | 1700    | 2500    |
+        | \( W_p \)     | Paint weight \((\text{lb/ft}^2)\)      | 0.064 |   0.025  | 0.08    |
 
         Args:
             X (np.ndarray):
@@ -511,8 +512,93 @@ def fun_wingwt(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nd
         Wdg = X[:, 8] * 800 + 1700  # equivalent to (2500 - 1700) + 1700
         Wp = X[:, 9] * 0.055 + 0.025  # equivalent to (0.08 - 0.025) + 0.025
         # Calculate W for all rows in a vectorized manner
-        W = 0.036 * Sw**0.758 * Wfw**0.0035 * (A / np.cos(L) ** 2) ** 0.6 * q**0.006
-        W *= la**0.04 * (100 * Rtc / np.cos(L)) ** (-0.3) * (Nz * Wdg) ** (0.49)
+        W = 0.036 * Sw**0.758 * Wfw**0.0035
+        W *= (A / np.cos(L) ** 2) ** 0.6 * q**0.006
+        W *= la**0.04
+        print(f"W: {W}")
+        print(f"(100 * Rtc / np.cos(L)): {(100 * Rtc / np.cos(L))}")
+        W *= (100 * Rtc / np.cos(L)) ** (-0.3)
+        print(f"W: {W}")
+        W *= (Nz * Wdg) ** (0.49)
+        W += Sw * Wp
+        return self._add_noise(y=W)
+
+    def fun_wingwt(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndarray:
+        r"""Wing weight function. Returns coded, not natural values.
+        Calculate the weight of an unpainted light aircraft wing based on design and operational parameters.
+        This function implements the wing weight model from Forrester et al., which aims to predict
+        the wing weight \( W \) using the following formula:
+
+        \[
+        W = 0.036 \times S_W^{0.758} \times W_{fw}^{0.0035} \times \left( \frac{A}{\cos^2 \Lambda} \right)^{0.6}
+        \times q^{0.006} \times \lambda^{0.04} \times \left( \frac{100 \times R_{tc}}{\cos \Lambda} \right)^{-0.3}
+        \times (N_z \times W_{dg})^{0.49} + S_W \times W_p
+        \]
+
+        where:
+
+        - \( S_W \): Wing area \((\text{ft}^2)\)
+        - \( W_{fw} \): Weight of fuel in the wing (lb)
+        - \( A \): Aspect ratio
+        - \( \Lambda \): Quarter-chord sweep (degrees)
+        - \( q \): Dynamic pressure at cruise \((\text{lb/ft}^2)\)
+        - \( \lambda \): Taper ratio
+        - \( R_{tc} \): Aerofoil thickness to chord ratio
+        - \( N_z \): Ultimate load factor
+        - \( W_{dg} \): Flight design gross weight (lb)
+        - \( W_p \): Paint weight \((\text{lb/ft}^2)\)
+
+        Parameter Overview:
+
+        | Symbol    | Parameter                              | Baseline | Minimum | Maximum |
+        |-----------|----------------------------------------|----------|---------|---------|
+        | \( S_W \)     | Wing area \((\text{ft}^2)\)            | 174      | 150     | 200     |
+        | \( W_{fw} \)  | Weight of fuel in wing (lb)            | 252      | 220     | 300     |
+        | \( A \)       | Aspect ratio                          | 7.52     | 6       | 10      |
+        | \( \Lambda \) | Quarter-chord sweep (deg)              | 0        | -10     | 10      |
+        | \( q \)       | Dynamic pressure at cruise \((\text{lb/ft}^2)\) | 34       | 16      | 45      |
+        | \( \lambda \) | Taper ratio                            | 0.672    | 0.5     | 1       |
+        | \( R_{tc} \)  | Aerofoil thickness to chord ratio      | 0.12     | 0.08    | 0.18    |
+        | \( N_z \)     | Ultimate load factor                   | 3.8      | 2.5     | 6       |
+        | \( W_{dg} \)  | Flight design gross weight (lb)        | 2000     | 1700    | 2500    |
+        | \( W_p \)     | Paint weight \((\text{lb/ft}^2)\)      | 0.064 |   0.025  | 0.08    |
+
+        Args:
+            X (np.ndarray):
+                A 2D numpy array where each row contains 10 parameters for which the wing weight will be calculated.
+            fun_control (Optional[Dict]):
+                A dictionary with keys `sigma` (noise level) and `seed` (random seed)
+                for incorporating randomness if required. Default is `None`.
+
+        Returns:
+            np.ndarray:
+            A 1D numpy array with shape (n,) containing the calculated wing weight values.
+
+        Examples:
+            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> import numpy as np
+            >>> X = np.array([np.zeros(10), np.ones(10)])
+            >>> fun = analytical()
+            >>> fun.fun_wingwt(X)
+            array([158.28245046, 409.33182691])
+        """
+        X = self._prepare_input_data(X, fun_control)
+        Sw = X[:, 0]
+        Wfw = X[:, 1]
+        A = X[:, 2]
+        L = X[:, 3] * np.pi / 180
+        q = X[:, 4]
+        la = X[:, 5]
+        Rtc = X[:, 6]
+        Nz = X[:, 7]
+        Wdg = X[:, 8]
+        Wp = X[:, 9]
+        # Calculate W for all rows in a vectorized manner
+        W = 0.036 * Sw**0.758 * Wfw**0.0035
+        W *= (A / np.cos(L) ** 2) ** 0.6 * q**0.006
+        W *= la**0.04
+        W *= (100 * Rtc / np.cos(L)) ** (-0.3)
+        W *= (Nz * Wdg) ** (0.49)
         W += Sw * Wp
         return self._add_noise(y=W)
 
diff --git a/src/spotpython/utils/effects.py b/src/spotpython/utils/effects.py
@@ -52,7 +52,7 @@ def screeningplan(k, p, xi, r):
     return X
 
 
-def screening(X, fun, xi, p, labels, range=None, print=False) -> pd.DataFrame:
+def screening(X, fun, xi, p, labels, bounds=None, print=False) -> pd.DataFrame:
     """Generates a DataFrame with elementary effect screening metrics.
 
     This function calculates the mean and standard deviation of the
@@ -68,7 +68,7 @@ def screening(X, fun, xi, p, labels, range=None, print=False) -> pd.DataFrame:
         p (int): Number of discrete levels along each dimension.
         labels (list of str): A list of variable names corresponding to
             the design variables.
-        range (np.ndarray): A 2xk matrix where the first row contains
+        bounds (np.ndarray): A 2xk matrix where the first row contains
             lower bounds and the second row contains upper bounds for
             each variable.
 
@@ -78,66 +78,74 @@ def screening(X, fun, xi, p, labels, range=None, print=False) -> pd.DataFrame:
             - 'mean': The mean of the elementary effects for each variable.
             - 'sd': The standard deviation of the elementary effects for
             each variable.
+        or None: If print is set to False, a plot of the results is
+            generated instead of returning a DataFrame.
 
     Examples:
         >>> import numpy as np
-        >>> from spotpython.fun.objectivefunctions import Analytical
-        >>> from spotpython.utils.effects import screening
-        >>>
-        >>> # Create a small test input with shape (n, 10)
-        >>> X_test = np.array([
-        ...     [0.0]*10,
-        ...     [1.0]*10
-        ... ])
-        >>> fun = Analytical()
-        >>> labels = ["x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10"]
-        >>> result = screening(X_test, fun.fun_wingwt, np.array([[0]*10, [1]*10]), 0.1, 3, labels)
-        >>> print
+            from spotpython.utils.effects import screening, screeningplan
+            from spotpython.fun.objectivefunctions import Analytical
+            fun = Analytical()
+            k = 10
+            p = 10
+            xi = 1
+            r = 25
+            X = screeningplan(k=k, p=p, xi=xi, r=r)  # shape (r x (k+1), k)
+            # Provide real-world bounds from the wing weight docs (2 x 10).
+            value_range = np.array([
+                [150, 220,   6, -10, 16, 0.5, 0.08, 2.5, 1700, 0.025],
+                [200, 300,  10,  10, 45, 1.0, 0.18, 6.0, 2500, 0.08 ],
+            ])
+            labels = [
+                "S_W", "W_fw", "A", "Lambda",
+                "q",   "lambda", "tc", "N_z",
+                "W_dg", "W_p"
+            ]
+            screening(
+                X=X,
+                fun=fun.fun_wingwt,
+                bounds=value_range,
+                xi=xi,
+                p=p,
+                labels=labels,
+                print=False,
+            )
     """
-    # Determine the number of design variables (k)
     k = X.shape[1]
-    # Determine the number of repetitions (r)
     r = X.shape[0] // (k + 1)
 
-    # Scale each design point to the given range and evaluate the objective function
+    # Scale each design point
     t = np.zeros(X.shape[0])
     for i in range(X.shape[0]):
-        if range is not None:
-            X[i, :] = range[0, :] + X[i, :] * (range[1, :] - range[0, :])
+        if bounds is not None:
+            X[i, :] = bounds[0, :] + X[i, :] * (bounds[1, :] - bounds[0, :])
         t[i] = fun(X[i, :])
 
-    # Calculate the elementary effects
+    # Elementary effects
     F = np.zeros((k, r))
     for i in range(r):
         for j in range(i * (k + 1), i * (k + 1) + k):
-            index = np.where(X[j, :] - X[j + 1, :] != 0)[0][0]
-            F[index, i] = (t[j + 1] - t[j]) / (xi / (p - 1))
+            idx = np.where(X[j, :] - X[j + 1, :] != 0)[0][0]
+            F[idx, i] = (t[j + 1] - t[j]) / (xi / (p - 1))
 
-    # Compute statistical measures
-    ssd = np.std(F, axis=1)
-    sm = np.abs(np.mean(F, axis=1))
+    # Statistical measures (divide by n)
+    ssd = np.std(F, axis=1, ddof=0)
+    sm = np.mean(F, axis=1)
 
     if print:
-        # sort the variables by decreasing mean
-        idx = np.argsort(-sm)
-        labels = [labels[i] for i in idx]
+        idx = np.argsort(-np.abs(sm))
+        sorted_labels = [labels[i] for i in idx]
         sm = sm[idx]
         ssd = ssd[idx]
-        df = pd.DataFrame({"varname": labels, "mean": sm, "sd": ssd})
-
+        df = pd.DataFrame({"varname": sorted_labels, "mean": sm, "sd": ssd})
         return df
     else:
-        # Generate plot
         plt.figure()
-
         for i in range(k):
             plt.text(sm[i], ssd[i], labels[i], fontsize=10)
-
         plt.axis([min(sm), 1.1 * max(sm), min(ssd), 1.1 * max(ssd)])
         plt.xlabel("Sample means")
         plt.ylabel("Sample standard deviations")
-        plt.gca().set_xlabel("Sample means")
-        plt.gca().set_ylabel("Sample standard deviations")
         plt.gca().tick_params(labelsize=10)
         plt.grid(True)
         plt.show()
diff --git a/test/test_effects.py b/test/test_effects.py
@@ -0,0 +1,73 @@
+import numpy as np
+import pandas as pd
+import pytest
+from spotpython.utils.effects import screening
+
+def mock_objective_function(x):
+    """Mock objective function for testing."""
+    return np.sum(x**2)
+
+
+@pytest.fixture
+def test_data():
+    """Fixture to provide test data."""
+    X = np.array([
+        [0.0, 0.0],
+        [0.1, 0.0],
+        [0.0, 0.1],
+        [0.1, 0.1]
+    ])
+    labels = ["x1", "x2"]
+    range_ = np.array([[0, 0], [1, 1]])
+    return X, labels, range_
+
+
+def test_screening_dataframe_output(test_data):
+    """Test if screening returns a DataFrame with correct structure."""
+    X, labels, range_ = test_data
+    xi = 0.1
+    p = 3
+
+    result = screening(X, mock_objective_function, xi, p, labels, bounds=range_, print=True)
+
+    assert isinstance(result, pd.DataFrame), "Output should be a DataFrame"
+    assert set(result.columns) == {"varname", "mean", "sd"}, "DataFrame should have columns 'varname', 'mean', and 'sd'"
+    assert len(result) == len(labels), "DataFrame should have one row per variable"
+
+
+def test_screening_mean_and_sd_calculation(test_data):
+    """Test if the mean and standard deviation are calculated correctly."""
+    X, labels, range_ = test_data
+    xi = 0.1
+    p = 3
+
+    result = screening(X, mock_objective_function, xi, p, labels, bounds=range_, print=True)
+
+    # Check if mean and standard deviation are non-negative
+    assert (result["mean"] >= 0).all(), "Mean values should be non-negative"
+    assert (result["sd"] >= 0).all(), "Standard deviation values should be non-negative"
+
+
+def test_screening_with_no_range(test_data):
+    """Test screening function when no bounds is provided."""
+    X, labels, _ = test_data
+    xi = 0.1
+    p = 3
+
+    result = screening(X, mock_objective_function, xi, p, labels, bounds=None, print=True)
+
+    assert isinstance(result, pd.DataFrame), "Output should be a DataFrame"
+    assert len(result) == len(labels), "DataFrame should have one row per variable"
+
+
+def test_screening_plot_output(test_data):
+    """Test if screening generates a plot when print=False."""
+    X, labels, range_ = test_data
+    xi = 0.1
+    p = 3
+
+    # Ensure no exceptions are raised during plotting
+    try:
+        screening(X, mock_objective_function, xi, p, labels, bounds=range_, print=False)
+    except Exception as e:
+        pytest.fail(f"Plotting failed with exception: {e}")
