Merge remote-tracking branch 'origin/master' into mypy

Author: basnijholt

adaptive/learner/average_learner.py

@@ -74,6 +74,10 @@ def __init__(
         self.sum_f: Real = 0.0
         self.sum_f_sq: Real = 0.0
 
+    def new(self) -> AverageLearner:
+        """Create a copy of `~adaptive.AverageLearner` without the data."""
+        return AverageLearner(self.function, self.atol, self.rtol, self.min_npoints)
+
     @property
     def n_requested(self) -> int:
         return self.npoints + len(self.pending_points)

adaptive/learner/average_learner1D.py

@@ -125,6 +125,20 @@ def __init__(
         # {xii: error[xii]/min(_distances[xi], _distances[xii], ...}
         self.rescaled_error: dict[Real, float] = decreasing_dict()
 
+    def new(self) -> AverageLearner1D:
+        """Create a copy of `~adaptive.AverageLearner1D` without the data."""
+        return AverageLearner1D(
+            self.function,
+            self.bounds,
+            self.loss_per_interval,
+            self.delta,
+            self.alpha,
+            self.neighbor_sampling,
+            self.min_samples,
+            self.max_samples,
+            self.min_error,
+        )
+
     @property
     def nsamples(self) -> int:
         """Returns the total number of samples"""

adaptive/learner/balancing_learner.py

@@ -118,6 +118,14 @@ def __init__(
 
         self.strategy: STRATEGY_TYPE = strategy
 
+    def new(self) -> BalancingLearner:
+        """Create a new `BalancingLearner` with the same parameters."""
+        return BalancingLearner(
+            [learner.new() for learner in self.learners],
+            cdims=self._cdims_default,
+            strategy=self.strategy,
+        )
+
     @property
     def data(self) -> dict[tuple[int, Any], Any]:
         data = {}

adaptive/learner/base_learner.py

@@ -157,6 +157,11 @@ def _get_data(self):
     def _set_data(self, data: Any):
         pass
 
+    @abc.abstractmethod
+    def new(self):
+        """Return a new learner with the same function and parameters."""
+        pass
+
     def copy_from(self, other):
         """Copy over the data from another learner.
 

adaptive/learner/data_saver.py

@@ -47,6 +47,10 @@ def __init__(self, learner: BaseLearner, arg_picker: itemgetter) -> None:
         self.function = learner.function
         self.arg_picker = arg_picker
 
+    def new(self) -> DataSaver:
+        """Return a new `DataSaver` with the same `arg_picker` and `learner`."""
+        return DataSaver(self.learner.new(), self.arg_picker)
+
     def __getattr__(self, attr: str) -> Any:
         return getattr(self.learner, attr)
 

adaptive/learner/integrator_learner.py

@@ -390,6 +390,10 @@ def __init__(self, function: Callable, bounds: tuple[int, int], tol: float) -> N
         self.add_ival(ival)
         self.first_ival = ival
 
+    def new(self) -> IntegratorLearner:
+        """Create a copy of `~adaptive.Learner2D` without the data."""
+        return IntegratorLearner(self.function, self.bounds, self.tol)
+
     @property
     def approximating_intervals(self) -> set[_Interval]:
         return self.first_ival.done_leaves

adaptive/learner/learner1D.py

@@ -22,6 +22,12 @@
     partial_function_from_dataframe,
 )
 
+try:
+    from typing import TypeAlias
+except ImportError:
+    # Remove this when we drop support for Python 3.9
+    from typing_extensions import TypeAlias
+
 try:
     import pandas
 
@@ -33,21 +39,21 @@
 # -- types --
 
 # Commonly used types
-Interval = Union[Tuple[float, float], Tuple[float, float, int]]
-NeighborsType = Dict[float, List[Union[float, None]]]
+Interval: TypeAlias = Union[Tuple[float, float], Tuple[float, float, int]]
+NeighborsType: TypeAlias = Dict[float, List[Union[float, None]]]
 
 # Types for loss_per_interval functions
-NoneFloat = Union[Float, None]
-NoneArray = Union[np.ndarray, None]
-XsType0 = Tuple[Float, Float]
-YsType0 = Union[Tuple[Float, Float], Tuple[np.ndarray, np.ndarray]]
-XsType1 = Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat]
-YsType1 = Union[
+NoneFloat: TypeAlias = Union[Float, None]
+NoneArray: TypeAlias = Union[np.ndarray, None]
+XsType0: TypeAlias = Tuple[Float, Float]
+YsType0: TypeAlias = Union[Tuple[Float, Float], Tuple[np.ndarray, np.ndarray]]
+XsType1: TypeAlias = Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat]
+YsType1: TypeAlias = Union[
     Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat],
     Tuple[NoneArray, NoneArray, NoneArray, NoneArray],
 ]
-XsTypeN = Tuple[NoneFloat, ...]
-YsTypeN = Union[Tuple[NoneFloat, ...], Tuple[NoneArray, ...]]
+XsTypeN: TypeAlias = Tuple[NoneFloat, ...]
+YsTypeN: TypeAlias = Union[Tuple[NoneFloat, ...], Tuple[NoneArray, ...]]
 
 
 __all__ = [
@@ -303,11 +309,15 @@ def __init__(
         # The precision in 'x' below which we set losses to 0.
         self._dx_eps = 2 * max(np.abs(bounds)) * np.finfo(float).eps
 
-        self.bounds = list(bounds)
+        self.bounds = tuple(bounds)
         self.__missing_bounds = set(self.bounds)  # cache of missing bounds
 
         self._vdim: int | None = None
 
+    def new(self) -> Learner1D:
+        """Create a copy of `~adaptive.Learner1D` without the data."""
+        return Learner1D(self.function, self.bounds, self.loss_per_interval)
+
     @property
     def vdim(self) -> int:
         """Length of the output of ``learner.function``.

adaptive/learner/learner2D.py

@@ -393,6 +393,9 @@ def __init__(
 
         self.stack_size = 10
 
+    def new(self) -> Learner2D:
+        return Learner2D(self.function, self.bounds, self.loss_per_triangle)
+
     @property
     def xy_scale(self) -> np.ndarray:
         xy_scale = self._xy_scale

adaptive/learner/learnerND.py

@@ -395,6 +395,10 @@ def __init__(
         # _pop_highest_existing_simplex
         self._simplex_queue = SortedKeyList(key=_simplex_evaluation_priority)
 
+    def new(self) -> LearnerND:
+        """Create a new learner with the same function and bounds."""
+        return LearnerND(self.function, self.bounds, self.loss_per_simplex)
+
     @property
     def npoints(self) -> int:
         """Number of evaluated points."""

adaptive/learner/sequence_learner.py

@@ -81,6 +81,10 @@ def __init__(self, function: Callable, sequence: Iterable) -> None:
         self.data = SortedDict()
         self.pending_points = set()
 
+    def new(self) -> SequenceLearner:
+        """Return a new `~adaptive.SequenceLearner` without the data."""
+        return SequenceLearner(self._original_function, self.sequence)
+
     def ask(self, n: int, tell_pending: bool = True) -> tuple[Any, list[float]]:
         indices = []
         points = []
@@ -179,7 +183,7 @@ def to_dataframe(
         df.attrs["inputs"] = [index_name]
         df.attrs["output"] = y_name
         if with_default_function_args:
-            assign_defaults(self.function, df, function_prefix)
+            assign_defaults(self._original_function, df, function_prefix)
         return df
 
     def load_dataframe(
@@ -216,7 +220,7 @@ def load_dataframe(
         self.tell_many(df[[index_name, x_name]].values, df[y_name].values)
         if with_default_function_args:
             self.function = partial_function_from_dataframe(
-                self.function, df, function_prefix
+                self._original_function, df, function_prefix
             )
 
     def _get_data(self) -> SortedDict: