0.31.10

bartzbeielstein · bartzbeielstein · commit c2590f1a616e · 2025-08-02T21:55:42.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,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.31.9"
+version = "0.31.10"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]
diff --git a/src/spotpython/fun/objectivefunctions.py b/src/spotpython/fun/objectivefunctions.py
@@ -49,7 +49,7 @@ def __init__(self, offset: float = 0.0, sigma=0.0, seed: int = 126, fun_control=
             self.fun_control["seed"] = self.seed
 
     def __repr__(self) -> str:
-        return f"analytical(offset={self.offset}, sigma={self.sigma}, seed={self.seed})"
+        return f"Analytical(offset={self.offset}, sigma={self.sigma}, seed={self.seed})"
 
     def _prepare_input_data(self, X, fun_control):
         if fun_control is not None:
@@ -67,17 +67,17 @@ def _add_noise(self, y: List[float]) -> np.ndarray:
         containing the noisy data.
 
         Args:
-            self (analytical): analytical class object.
+            self (Analytical): Analytical class object.
             y (List[float]): Input data.
 
         Returns:
             np.ndarray: Noisy data.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
                 import numpy as np
                 y = np.array([1, 2, 3, 4, 5])
-                fun = analytical(sigma=1.0, seed=123)
+                fun = Analytical(sigma=1.0, seed=123)
                 fun._add_noise(y)
             array([0.01087865, 1.63221335, 4.28792526, 4.19397442, 5.9202309 ])
 
@@ -117,10 +117,10 @@ def fun_branin_factor(self, X: np.ndarray, fun_control: Optional[Dict] = None) -
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
                 import numpy as np
                 X = np.array([[0, 0, 0], [0, 0, 1], [0, 0, 2]])
-                fun = analytical()
+                fun = Analytical()
                 fun.fun_branin_factor(X)
                 array([55.60211264, 65.60211264, 45.60211264])
         """
@@ -230,10 +230,10 @@ def fun_sphere(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nd
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3], [4, 5, 6]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_sphere(X)
             array([14., 77.])
 
@@ -256,10 +256,10 @@ def fun_cubed(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nda
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3], [4, 5, 6], [-1, -1, -1]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_cubed(X)
             array([ 36., 405., -3.])
         """
@@ -283,10 +283,10 @@ def fun_forrester(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3], [4, 5, 6]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_forrester(X)
             array([  0.        ,  11.99999999])
         """
@@ -324,13 +324,13 @@ def fun_branin(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nd
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
                 pi = np.pi
                 X = np.array([[0,0],
                     [-pi, 12.275],
                     [pi, 2.275],
                     [9.42478, 2.475]])
-                fun = analytical()
+                fun = Analytical()
                 fun.fun_branin(X)
                 array([55.60211264,  0.39788736,  0.39788736,  0.39788736])
 
@@ -362,10 +362,10 @@ def fun_branin_modified(self, X: np.ndarray, fun_control: Optional[Dict] = None)
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3], [4, 5, 6]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_branin_modified(X)
             array([  0.        ,  11.99999999])
 
@@ -398,10 +398,10 @@ def fun_sin_cos(self, X, fun_control=None):
             (np.ndarray): A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3], [4, 5, 6]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_sin_cos(X)
             array([-1.        , -0.41614684])
         """
@@ -425,10 +425,10 @@ def fun_runge(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nda
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3], [4, 5, 6]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_runge(X)
             array([0.0625    , 0.015625  , 0.00390625])
 
@@ -493,10 +493,10 @@ def fun_wingwt_to_nat(self, X: np.ndarray, fun_control: Optional[Dict] = None) -
             A 1D numpy array with shape (n,) containing the calculated wing weight values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([np.zeros(10), np.ones(10)])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_wingwt(X)
             array([158.28245046, 409.33182691])
         """
@@ -575,10 +575,10 @@ def fun_wingwt(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nd
             A 1D numpy array with shape (n,) containing the calculated wing weight values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([np.zeros(10), np.ones(10)])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_wingwt(X)
             array([158.28245046, 409.33182691])
         """
@@ -612,10 +612,10 @@ def fun_xsin(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.ndar
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2, 3, 4, 5, 6, 7, 8, 9], [4, 5, 6, 7, 8, 9, 10, 11, 12]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_xsin(X)
             array([0.84147098, 0.90929743, 0.14112001])
 
@@ -634,10 +634,10 @@ def fun_rosen(self, X: np.ndarray, fun_control: Optional[Dict] = None) -> np.nda
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2,], [4, 5 ]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_rosen(X)
             array([24,  0])
         """
@@ -660,10 +660,10 @@ def fun_random_error(self, X: np.ndarray, fun_control: Optional[Dict] = None) ->
             np.ndarray: A 1D numpy array with shape (n,) containing the calculated values.
 
         Examples:
-            >>> from spotpython.fun.objectivefunctions import analytical
+            >>> from spotpython.fun.objectivefunctions import Analytical
             >>> import numpy as np
             >>> X = np.array([[1, 2,], [4, 5 ]])
-            >>> fun = analytical()
+            >>> fun = Analytical()
             >>> fun.fun_random_error(X)
             array([24,  0])
 
diff --git a/src/spotpython/spot/spot.py b/src/spotpython/spot/spot.py
@@ -51,7 +51,7 @@
 from typing import Callable
 from spotpython.utils.numpy2json import NumpyEncoder
 from spotpython.utils.file import load_result
-from spotpython.surrogate.plot import plot_3d_contour, plotkd
+from spotpython.surrogate.plot import plotkd
 
 # Setting up the backend to use QtAgg
 # matplotlib.use("TkAgg")
@@ -2528,84 +2528,9 @@ def plot_contour(
         cmap="jet",
     ) -> None:
         """
-        Plot the contour and 3D surface for any pair of dimensions of the surrogate model.
-        This method visualizes the surrogate model's predictions over a grid for two selected dimensions.
-        It creates both a filled contour plot and a 3D surface plot, allowing users to inspect the surrogate's
-        response surface. The remaining dimensions are fixed to either their minimum or maximum values, depending
-        on the `use_min` and `use_max` flags.
+        Plot a contour plot of the surrogate model for two hyperparameters.
         """
-        plotkd(model=self.surrogate, X=self.X, y=self.y, i=i, j=j, num=n_grid)
-
-    def plot_contour_old(
-        self,
-        i=0,
-        j=1,
-        min_z=None,
-        max_z=None,
-        show=True,
-        title=None,
-        filename=None,
-        n_grid=50,
-        contour_levels=10,
-        dpi=200,
-        figsize=(12, 5),
-        use_min=False,
-        use_max=True,
-        tkagg=False,
-        cmap="jet",
-    ) -> None:
-        """
-        Plot the contour and 3D surface for any pair of dimensions of the surrogate model.
-        This method visualizes the surrogate model's predictions over a grid for two selected dimensions.
-        It creates both a filled contour plot and a 3D surface plot, allowing users to inspect the surrogate's
-        response surface. The remaining dimensions are fixed to either their minimum or maximum values, depending
-        on the `use_min` and `use_max` flags.
-
-        Args:
-            i (int, optional): Index of the first dimension to plot. Default is 0.
-            j (int, optional): Index of the second dimension to plot. Default is 1.
-            min_z (float, optional): Minimum value for the color scale (z-axis). If None, determined automatically.
-            max_z (float, optional): Maximum value for the color scale (z-axis). If None, determined automatically.
-            show (bool, optional): Whether to display the plot interactively. Default is True.
-            filename (str, optional): If provided, saves the plot to this file. Default is None.
-            n_grid (int, optional): Number of grid points per dimension. Default is 50.
-            contour_levels (int, optional): Number of contour levels. Default is 10.
-            dpi (int, optional): Dots per inch for saved figure. Default is 200.
-            title (str, optional): Title for the plot. Default is None.
-            figsize (tuple, optional): Figure size in inches (width, height). Default is (12, 6).
-            use_min (bool, optional): If True, fix hidden dimensions to their minimum values. Default is False.
-            use_max (bool, optional): If True, fix hidden dimensions to their maximum values. Default is True.
-            tkagg (bool, optional): If True, use TkAgg backend for matplotlib. Default is False.
-            cmap (str, optional): Colormap to use for the contour plot. Default is "jet".
-
-        Returns:
-            None
-        """
-        X, Y, Z = self.prepare_plot(
-            i=i,
-            j=j,
-            n_grid=n_grid,
-            use_min=use_min,
-            use_max=use_max,
-        )
-        plot_3d_contour(
-            X=X,
-            Y=Y,
-            Z=Z,
-            vmin=min_z if min_z is not None else np.min(Z),
-            vmax=max_z if max_z is not None else np.max(Z),
-            var_name=self.var_name,
-            i=i,
-            j=j,
-            show=show,
-            filename=filename,
-            contour_levels=contour_levels,
-            dpi=dpi,
-            title=title,
-            figsize=figsize,
-            tkagg=tkagg,
-            cmap=cmap,
-        )
+        plotkd(model=self.surrogate, X=self.X, y=self.y, i=i, j=j, num=n_grid, var_type=self.var_type)
 
     def plot_important_hyperparameter_contour(
         self,
diff --git a/src/spotpython/surrogate/kriging.py b/src/spotpython/surrogate/kriging.py
@@ -5,9 +5,7 @@
 from sklearn.base import BaseEstimator, RegressorMixin
 from scipy.special import erf
 import matplotlib.pyplot as plt
-from numpy import linspace, meshgrid, array, append
-import pylab
-from numpy import ravel
+from numpy import linspace, append
 from scipy.spatial.distance import cdist, pdist, squareform
 from spotpython.surrogate.plot import plotkd
 
@@ -789,8 +787,6 @@ def plot(self, i: int = 0, j: int = 1, show: Optional[bool] = True) -> None:
                 S.surrogate.plot()
         """
         if self.k == 1:
-            # TODO: Improve plot (add conf. interval etc.)
-            fig = pylab.figure(figsize=(9, 6))
             n_grid = 100
             x = linspace(self.min_X[0], self.max_X[0], num=n_grid)
             y = self.predict(x)
@@ -799,4 +795,4 @@ def plot(self, i: int = 0, j: int = 1, show: Optional[bool] = True) -> None:
             if show:
                 plt.show()
         else:
-            plotkd(model=self, X=self.X_, y=self.y_, i=i, j=j, show=show)
+            plotkd(model=self, X=self.X_, y=self.y_, i=i, j=j, show=show, var_type=self.var_type)
diff --git a/src/spotpython/surrogate/plot.py b/src/spotpython/surrogate/plot.py
@@ -56,12 +56,7 @@ def plot1d(model, X: np.ndarray, y: np.ndarray, show: Optional[bool] = True) ->
 
 
 def generate_mesh_grid(
-    X: Optional[np.ndarray] = None,
-    i: int = 0,
-    j: int = 1,
-    num: int = 100,
-    lower: Optional[np.ndarray] = None,
-    upper: Optional[np.ndarray] = None,
+    X: Optional[np.ndarray] = None, i: int = 0, j: int = 1, num: int = 100, lower: Optional[np.ndarray] = None, upper: Optional[np.ndarray] = None, var_type: Optional[List[str]] = None
 ):
     """
     Generate a mesh grid for two selected dimensions, filling remaining dimensions with their mean values
@@ -74,6 +69,7 @@ def generate_mesh_grid(
         num (int): Number of grid points per dimension.
         lower (np.ndarray, optional): Lower bounds for each dimension (shape (k,)).
         upper (np.ndarray, optional): Upper bounds for each dimension (shape (k,)).
+        var_type (list of str, optional): List of variable types for each dimension. Can be either "num", "int", or "factor".
 
     Returns:
         X_i (np.ndarray): Meshgrid for the i-th dimension.
@@ -95,6 +91,17 @@ def generate_mesh_grid(
         x_i = linspace(lower[i], upper[i], num=num)
         x_j = linspace(lower[j], upper[j], num=num)
 
+    # Masked rounding (using floor) for integer or factor variables
+    if var_type is not None:
+        # For x_i
+        if hasattr(x_i, "__len__"):
+            mask_i = np.array([var_type[i] != "num"] * len(x_i))
+            x_i = np.where(mask_i, np.floor(x_i), x_i)
+        # For x_j
+        if hasattr(x_j, "__len__"):
+            mask_j = np.array([var_type[j] != "num"] * len(x_j))
+            x_j = np.where(mask_j, np.floor(x_j), x_j)
+
     X_i, X_j = meshgrid(x_i, x_j)
     grid_points = np.zeros((X_i.size, k))
     grid_points[:, i] = X_i.ravel()
@@ -334,6 +341,7 @@ def plotkd(
     eps: float = 1e-4,
     max_error: float = 1e-3,
     var_names: Optional[List[str]] = None,
+    var_type: Optional[List[str]] = None,
     cmap: str = "jet",
     num: int = 100,
     vmin: Optional[float] = None,
@@ -354,6 +362,7 @@ def plotkd(
         eps (float): Tolerance for coloring points based on prediction error. Default is 1e-4.
         max_error (float): Maximum error for color scaling. Default is 1e-3.
         var_names (list of str, optional): List of variable names for axis labeling. If None, generic labels are used.
+        var_type (list of str, optional): List of variable types for each dimension. Can be either "num", "int", or "factor".
         cmap (str): Colormap for the surface and contour plots. Default is "jet".
         num (int): Number of grid points per dimension for the mesh grid. Default is 100.
         vmin (float, optional): Minimum value for the color scale. If None, determined from predictions.
@@ -375,7 +384,7 @@ def plotkd(
     """
     k = X.shape[1]
     check_ij(i, j, k)
-    X_i, X_j, grid_points = generate_mesh_grid(X, i, j, num)
+    X_i, X_j, grid_points = generate_mesh_grid(X, i, j, num, var_type=var_type)
 
     # Predict the values and standard deviations
     y_pred, y_std = model.predict(grid_points, return_std=True)

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"`
`7`	`7`
`8`	`8`	`[project]`
`9`	`9`	`name = "spotpython"`
`10`		`-version = "0.31.9"`
	`10`	`+version = "0.31.10"`
`11`	`11`	`authors = [`
`12`	`12`	`{ name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }`
`13`	`13`	`]`