remove double Unions of float

Author: basnijholt

adaptive/learner/learner1D.py

@@ -19,10 +19,7 @@
 
 
 @uses_nth_neighbors(0)
-def uniform_loss(
-    xs: Union[Tuple[float, float], Tuple[float, float]],
-    ys: Union[Tuple[float, float], Tuple[float, float]],
-) -> Union[float, float]:
+def uniform_loss(xs: Tuple[float, float], ys: Tuple[float, float],) -> float:
     """Loss function that samples the domain uniformly.
 
     Works with `~adaptive.Learner1D` only.
@@ -62,7 +59,7 @@ def default_loss(
 
 
 @uses_nth_neighbors(1)
-def triangle_loss(xs: Any, ys: Any) -> Union[float, float]:
+def triangle_loss(xs: Any, ys: Any) -> float:
     xs = [x for x in xs if x is not None]
     ys = [y for y in ys if y is not None]
 
@@ -101,7 +98,7 @@ def curvature_loss(xs, ys):
 
 
 def linspace(
-    x_left: Union[int, float, float], x_right: Union[int, float, float], n: int,
+    x_left: Union[int, float], x_right: Union[int, float], n: int,
 ) -> Union[List[float], List[float]]:
     """This is equivalent to
     'np.linspace(x_left, x_right, n, endpoint=False)[1:]',
@@ -125,7 +122,7 @@ def _get_neighbors_from_list(xs: np.ndarray) -> SortedDict:
 
 
 def _get_intervals(
-    x: Union[int, float, float], neighbors: SortedDict, nth_neighbors: int
+    x: Union[int, float], neighbors: SortedDict, nth_neighbors: int
 ) -> Any:
     nn = nth_neighbors
     i = neighbors.index(x)
@@ -251,23 +248,21 @@ def npoints(self) -> int:
         return len(self.data)
 
     @cache_latest
-    def loss(self, real: bool = True) -> Union[int, float, float]:
+    def loss(self, real: bool = True) -> Union[int, float]:
         losses = self.losses if real else self.losses_combined
         if not losses:
             return np.inf
         max_interval, max_loss = losses.peekitem(0)
         return max_loss
 
-    def _scale_x(
-        self, x: Optional[Union[float, int, float]]
-    ) -> Optional[Union[float, float]]:
+    def _scale_x(self, x: Optional[Union[float, int]]) -> Optional[float]:
         if x is None:
             return None
         return x / self._scale[0]
 
     def _scale_y(
         self, y: Optional[Union[int, np.ndarray, float, float]]
-    ) -> Optional[Union[float, float, np.ndarray]]:
+    ) -> Optional[Union[float, np.ndarray]]:
         if y is None:
             return None
         y_scale = self._scale[1] or 1
@@ -279,8 +274,8 @@ def _get_point_by_index(self, ind: int) -> Optional[Union[int, float, float]]:
         return self.neighbors.keys()[ind]
 
     def _get_loss_in_interval(
-        self, x_left: Union[int, float, float], x_right: Union[int, float, float],
-    ) -> Union[int, float, float]:
+        self, x_left: Union[int, float], x_right: Union[int, float],
+    ) -> Union[int, float]:
         assert x_left is not None and x_right is not None
 
         if x_right - x_left < self._dx_eps:
@@ -301,7 +296,7 @@ def _get_loss_in_interval(
         return self.loss_per_interval(xs_scaled, ys_scaled)
 
     def _update_interpolated_loss_in_interval(
-        self, x_left: Union[int, float, float], x_right: Union[int, float, float],
+        self, x_left: Union[int, float], x_right: Union[int, float],
     ) -> None:
         if x_left is None or x_right is None:
             return
@@ -318,7 +313,7 @@ def _update_interpolated_loss_in_interval(
             self.losses_combined[a, b] = (b - a) * loss / dx
             a = b
 
-    def _update_losses(self, x: Union[int, float, float], real: bool = True) -> None:
+    def _update_losses(self, x: Union[int, float], real: bool = True) -> None:
         """Update all losses that depend on x"""
         # When we add a new point x, we should update the losses
         # (x_left, x_right) are the "real" neighbors of 'x'.
@@ -361,7 +356,7 @@ def _update_losses(self, x: Union[int, float, float], real: bool = True) -> None
             self.losses_combined[x, b] = float("inf")
 
     @staticmethod
-    def _find_neighbors(x: Union[int, float, float], neighbors: SortedDict) -> Any:
+    def _find_neighbors(x: Union[int, float], neighbors: SortedDict) -> Any:
         if x in neighbors:
             return neighbors[x]
         pos = neighbors.bisect_left(x)
@@ -370,17 +365,15 @@ def _find_neighbors(x: Union[int, float, float], neighbors: SortedDict) -> Any:
         x_right = keys[pos] if pos != len(neighbors) else None
         return x_left, x_right
 
-    def _update_neighbors(
-        self, x: Union[int, float, float], neighbors: SortedDict
-    ) -> None:
+    def _update_neighbors(self, x: Union[int, float], neighbors: SortedDict) -> None:
         if x not in neighbors:  # The point is new
             x_left, x_right = self._find_neighbors(x, neighbors)
             neighbors[x] = [x_left, x_right]
             neighbors.get(x_left, [None, None])[1] = x
             neighbors.get(x_right, [None, None])[0] = x
 
     def _update_scale(
-        self, x: Union[int, float, float], y: Union[float, int, float, np.ndarray],
+        self, x: Union[int, float], y: Union[float, int, float, np.ndarray],
     ) -> None:
         """Update the scale with which the x and y-values are scaled.
 
@@ -408,7 +401,7 @@ def _update_scale(
                 self._bbox[1][1] = max(self._bbox[1][1], y)
                 self._scale[1] = self._bbox[1][1] - self._bbox[1][0]
 
-    def tell(self, x: Union[int, float, float], y: Any) -> None:
+    def tell(self, x: Union[int, float], y: Any) -> None:
         if x in self.data:
             # The point is already evaluated before
             return
@@ -443,7 +436,7 @@ def tell(self, x: Union[int, float, float], y: Any) -> None:
 
             self._oldscale = deepcopy(self._scale)
 
-    def tell_pending(self, x: Union[int, float, float]) -> None:
+    def tell_pending(self, x: Union[int, float]) -> None:
         if x in self.data:
             # The point is already evaluated before
             return
@@ -659,7 +652,7 @@ def _set_data(self, data: Dict[Union[int, float], float]) -> None:
             self.tell_many(*zip(*data.items()))
 
 
-def loss_manager(x_scale: Union[int, float, float]) -> ItemSortedDict:
+def loss_manager(x_scale: Union[int, float]) -> ItemSortedDict:
     def sort_key(ival, loss):
         loss, ival = finite_loss(ival, loss, x_scale)
         return -loss, ival
@@ -668,9 +661,7 @@ def sort_key(ival, loss):
     return sorted_dict
 
 
-def finite_loss(
-    ival: Any, loss: Union[int, float, float], x_scale: Union[int, float, float],
-) -> Any:
+def finite_loss(ival: Any, loss: Union[int, float], x_scale: Union[int, float],) -> Any:
     """Get the socalled finite_loss of an interval in order to be able to
     sort intervals that have infinite loss."""
     # If the loss is infinite we return the

adaptive/learner/learner2D.py

@@ -583,15 +583,7 @@ def tell_pending(
 
     def _fill_stack(
         self, stack_till: int = 1
-    ) -> Union[
-        Tuple[List[Tuple[float, float]], List[float]],
-        Tuple[
-            List[Union[Tuple[float, float], Tuple[float, float], Tuple[float, float]]],
-            List[float],
-        ],
-        Tuple[List[Union[Tuple[float, float], Tuple[float, float]]], List[float]],
-        Tuple[List[Union[Tuple[float, float], Tuple[float, float]]], List[float]],
-    ]:
+    ) -> Tuple[List[Tuple[float, float]], List[float]]:
         if len(self.data) + len(self.pending_points) < self.ndim + 1:
             raise ValueError("too few points...")
 

adaptive/learner/learnerND.py

@@ -3,7 +3,6 @@
 import random
 from collections import OrderedDict
 from collections.abc import Iterable
-from functools import partial
 from typing import Any, Callable, List, Optional, Tuple, Union
 
 import numpy as np
@@ -133,7 +132,7 @@ def triangle_loss(
     value_scale: float,
     neighbors: Union[List[Union[None, np.ndarray]], List[None], List[np.ndarray]],
     neighbor_values: Union[List[Union[None, float]], List[None], List[float]],
-) -> Union[int, float, float]:
+) -> Union[int, float]:
     """
     Computes the average of the volumes of the simplex combined with each
     neighbouring point.
@@ -318,7 +317,7 @@ class LearnerND(BaseLearner):
 
     def __init__(
         self,
-        func: Union[Callable, partial],
+        func: Callable,
         bounds: Union[
             Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]],
             np.ndarray,

adaptive/learner/sequence_learner.py

@@ -26,7 +26,7 @@ def __call__(
         index_point: Union[Tuple[int, int], Tuple[int, float], Tuple[int, np.ndarray]],
         *args,
         **kwargs
-    ) -> Union[float, float]:
+    ) -> float:
         index, point = index_point
         return self.function(point, *args, **kwargs)
 
@@ -127,7 +127,7 @@ def tell(
             Tuple[int, np.ndarray],
             Tuple[int, None],
         ],
-        value: Union[float, float],
+        value: float,
     ) -> None:
         index, point = point
         self.data[index] = value

adaptive/learner/skopt_learner.py

@@ -49,7 +49,7 @@ def remove_unfinished(self):
         pass
 
     @cache_latest
-    def loss(self, real: bool = True) -> Union[float, float]:
+    def loss(self, real: bool = True) -> float:
         if not self.models:
             return np.inf
         else:

adaptive/tests/test_learners.py

@@ -126,17 +126,13 @@ def maybe_skip(learner: Type[SKOptLearner]) -> Type[SKOptLearner]:
 
 
 @learn_with(Learner1D, bounds=(-1, 1))
-def quadratic(
-    x: Union[int, float, float], m: uniform(0, 10), b: uniform(0, 1)
-) -> Union[float, float]:
+def quadratic(x: Union[int, float], m: uniform(0, 10), b: uniform(0, 1)) -> float:
     return m * x ** 2 + b
 
 
 @learn_with(Learner1D, bounds=(-1, 1))
 @learn_with(SequenceLearner, sequence=np.linspace(-1, 1, 201))
-def linear_with_peak(
-    x: Union[int, float, float], d: uniform(-1, 1)
-) -> Union[float, float]:
+def linear_with_peak(x: Union[int, float], d: uniform(-1, 1)) -> float:
     a = 0.01
     return x + a ** 2 / (a ** 2 + (x - d) ** 2)
 
@@ -153,7 +149,7 @@ def ring_of_fire(
         Tuple[float, float],
     ],
     d: uniform(0.2, 1),
-) -> Union[float, float]:
+) -> float:
     a = 0.2
     x, y = xy
     return x + math.exp(-((x ** 2 + y ** 2 - d ** 2) ** 2) / a ** 4)
@@ -164,7 +160,7 @@ def ring_of_fire(
 def sphere_of_fire(
     xyz: Union[Tuple[float, float, float], Tuple[int, int, int], np.ndarray],
     d: uniform(0.2, 1),
-) -> Union[float, float]:
+) -> float:
     a = 0.2
     x, y, z = xyz
     return x + math.exp(-((x ** 2 + y ** 2 + z ** 2 - d ** 2) ** 2) / a ** 4) + z ** 2
@@ -224,17 +220,7 @@ def ask_randomly(
     Tuple[List[Union[Tuple[float, float, float], Tuple[int, int, int]]], List[float]],
     Tuple[List[Union[Tuple[float, float], Tuple[int, int]]], List[float]],
     Tuple[List[float], List[float]],
-    Tuple[
-        List[
-            Union[
-                Tuple[int, int],
-                Tuple[float, float],
-                Tuple[float, float],
-                Tuple[float, float],
-            ]
-        ],
-        List[Union[float, float]],
-    ],
+    Tuple[List[Union[Tuple[int, int], Tuple[float, float]]], List[float]],
 ]:
     n_rounds = random.randrange(*rounds)
     n_points = [random.randrange(*points) for _ in range(n_rounds)]