Added support for continuous parameters sampling

src/f3dasm/_src/design/parameter.py

@@ -190,6 +190,34 @@ def _check_range(self):
                              f"(lower_bound={self.lower_bound}, \
                                  higher_bound={self.upper_bound}")
 
+    def to_discrete(self, step: int = 1) -> _DiscreteParameter:
+        """Convert the continuous parameter to a discrete parameter.
+
+        Parameters
+        ----------
+        step : int
+            The step size of the discrete search space, which defaults to 1.
+
+        Returns
+        -------
+        DiscreteParameter
+            The discrete parameter.
+
+        Raises
+        ------
+        ValueError
+            If the step size is less than or equal to 0.
+
+        """
+        if step <= 0:
+            raise ValueError("The step size must be larger than 0.")
+
+        return _DiscreteParameter(
+            lower_bound=int(self.lower_bound),
+            upper_bound=int(self.upper_bound),
+            step=step
+        )
+
 
 @dataclass
 class _DiscreteParameter(_Parameter):
@@ -251,7 +279,7 @@ def _check_range(self):
             raise ValueError("step size must be larger than 0!")
 
 
-@dataclass
+@ dataclass
 class _CategoricalParameter(_Parameter):
     """Create a search space parameter that is categorical
 

src/f3dasm/_src/design/samplers.py

@@ -14,7 +14,7 @@
 else:
     from typing import Literal
 
-from typing import Optional
+from typing import Dict, Optional
 
 # Third-party
 import numpy as np
@@ -107,7 +107,8 @@ def sample_continuous(self, numsamples: int) -> np.ndarray:
         """
         raise NotImplementedError("Subclasses should implement this method.")
 
-    def get_samples(self, numsamples: Optional[int] = None) -> pd.DataFrame:
+    def get_samples(
+            self, numsamples: Optional[int] = None, **kwargs) -> pd.DataFrame:
         """Receive samples of the search space
 
         Parameters
@@ -163,12 +164,12 @@ def get_samples(self, numsamples: Optional[int] = None) -> pd.DataFrame:
 
         return df
 
-    def __call__(self, domain: Domain, n_samples: int, seed: int):
+    def __call__(self, domain: Domain, n_samples: int, seed: int, **kwargs):
         """Call the sampler"""
         self.domain = domain
         self.number_of_samples = n_samples
         self.seed = seed
-        return self.get_samples()
+        return self.get_samples(**kwargs)
 
     def _sample_constant(self, numsamples: int):
         constant = self.domain.get_constant_parameters()
@@ -311,17 +312,33 @@ class GridSampler(Sampler):
 
     """
 
-    def get_samples(self, numsamples: Optional[int] = None) -> pd.DataFrame:
+    def get_samples(
+            self,
+            numsamples: Optional[int] = None,
+            stepsize_continuous_parameters:
+            Optional[Dict[str, float] | float] = None,
+            **kwargs) -> pd.DataFrame:
         """Receive samples of the search space
 
         Parameters
         ----------
-        numsamples
+        numsamples : int
             number of samples
+        stepsize_continuous_parameters : Dict[str, float] | float, optional
+            stepsize for the continuous parameters, by default None.
+            If a float is given, all continuous parameters are sampled with
+            the same stepsize. If a dictionary is given, the stepsize for each
+            continuous parameter can be specified.
 
         Returns
         -------
             Data objects with the samples
+
+        Raises
+        ------
+        ValueError
+            If the stepsize_continuous_parameters is given as a dictionary
+            and not specified for all continuous parameters.
         """
 
         self.set_seed(self.seed)
@@ -332,10 +349,21 @@ def get_samples(self, numsamples: Optional[int] = None) -> pd.DataFrame:
 
         continuous = self.domain.get_continuous_parameters()
 
-        if continuous:
-            raise ValueError("Grid sampling is only possible for domains \
-                             strictly with only discrete and \
-                            categorical parameters")
+        if isinstance(stepsize_continuous_parameters, float):
+            continuous = {key: continuous[key].to_discrete(
+                step=stepsize_continuous_parameters) for key in continuous}
+
+        elif isinstance(stepsize_continuous_parameters, dict):
+            continuous = {key: continuous[key].to_discrete(
+                step=value) for key,
+                value in stepsize_continuous_parameters.items()}
+
+            if len(continuous) != len(
+                    self.domain.get_continuous_parameters()):
+                raise ValueError(
+                    "If you specify the stepsize for continuous parameters, \
+                    the stepsize_continuous_parameters should \
+                    contain all continuous parameters")
 
         discrete = self.domain.get_discrete_parameters()
         categorical = self.domain.get_categorical_parameters()
@@ -346,7 +374,11 @@ def get_samples(self, numsamples: Optional[int] = None) -> pd.DataFrame:
             _iterdict[k] = v.categories
 
         for k, v, in discrete.items():
-            _iterdict[k] = range(v.lower_bound, v.upper_bound+1)
+            _iterdict[k] = range(v.lower_bound, v.upper_bound+1, v.step)
+
+        for k, v, in continuous.items():
+            _iterdict[k] = np.arange(
+                start=v.lower_bound, stop=v.upper_bound, step=v.step)
 
         return pd.DataFrame(list(product(*_iterdict.values())),
                             columns=_iterdict, dtype=object)

src/f3dasm/_src/experimentdata/experimentdata.py

@@ -1708,7 +1708,7 @@ def _iterate_scipy(self, optimizer: Optimizer,
     # =========================================================================
 
     def sample(self, sampler: Sampler | SamplerNames, n_samples: int = 1,
-               seed: Optional[int] = None) -> None:
+               seed: Optional[int] = None, **kwargs) -> None:
         """Sample data from the domain providing the sampler strategy
 
         Parameters
@@ -1726,6 +1726,17 @@ def sample(self, sampler: Sampler | SamplerNames, n_samples: int = 1,
         seed : Optional[int], optional
             Seed to use for the sampler, by default None
 
+        Note
+        ----
+        When using the 'grid' sampler, an optional argument
+        'stepsize_continuous_parameters' can be passed to specify the stepsize
+        to cast continuous parameters to discrete parameters.
+
+        - The stepsize should be a dictionary with the parameter names as keys\
+        and the stepsize as values.
+        - Alternatively, a single stepsize can be passed for all continuous\
+        parameters.
+
         Raises
         ------
         ValueError
@@ -1736,7 +1747,7 @@ def sample(self, sampler: Sampler | SamplerNames, n_samples: int = 1,
             sampler = _sampler_factory(sampler, self.domain)
 
         sample_data: DataTypes = sampler(
-            domain=self.domain, n_samples=n_samples, seed=seed)
+            domain=self.domain, n_samples=n_samples, seed=seed, **kwargs)
         self.add(input_data=sample_data, domain=self.domain)
 
     #                                                         Project directory

tests/design/test_space.py

@@ -177,5 +177,34 @@ def test_add_combination(args):
     assert a + b == expected
 
 
+def test_to_discrete():
+    a = _ContinuousParameter(0., 5.)
+    c = _DiscreteParameter(0, 5, 0.2)
+    b = a.to_discrete(0.2)
+    assert isinstance(b, _DiscreteParameter)
+    assert b.lower_bound == 0
+    assert b.upper_bound == 5
+    assert b.step == 0.2
+    assert b == c
+
+
+def test_to_discrete_negative_stepsize():
+    a = _ContinuousParameter(0., 5.)
+    with pytest.raises(ValueError):
+        a.to_discrete(-0.2)
+
+
+def test_default_stepsize_to_discrete():
+    default_stepsize = 1
+    a = _ContinuousParameter(0., 5.)
+    c = _DiscreteParameter(0, 5, default_stepsize)
+    b = a.to_discrete()
+    assert isinstance(b, _DiscreteParameter)
+    assert b.lower_bound == 0
+    assert b.upper_bound == 5
+    assert b.step == default_stepsize
+    assert b == c
+
+
 if __name__ == "__main__":  # pragma: no cover
     pytest.main()