use a normal float instead of np.float64

Author: basnijholt

adaptive/learner/learner1D.py

@@ -20,9 +20,9 @@
 
 @uses_nth_neighbors(0)
 def uniform_loss(
-    xs: Union[Tuple[float, float], Tuple[np.float64, np.float64]],
-    ys: Union[Tuple[float, float], Tuple[np.float64, np.float64]],
-) -> Union[np.float64, float]:
+    xs: Union[Tuple[float, float], Tuple[float, float]],
+    ys: Union[Tuple[float, float], Tuple[float, float]],
+) -> Union[float, float]:
     """Loss function that samples the domain uniformly.
 
     Works with `~adaptive.Learner1D` only.
@@ -43,18 +43,9 @@ def uniform_loss(
 
 @uses_nth_neighbors(0)
 def default_loss(
-    xs: Union[
-        Tuple[float, float],
-        Tuple[np.float64, float],
-        Tuple[np.float64, np.float64],
-        Tuple[float, np.float64],
-    ],
-    ys: Union[
-        Tuple[float, float],
-        Tuple[np.ndarray, np.ndarray],
-        Tuple[np.float64, np.float64],
-    ],
-) -> np.float64:
+    xs: Tuple[float, float],
+    ys: Union[Tuple[np.ndarray, np.ndarray], Tuple[float, float]],
+) -> float:
     """Calculate loss on a single interval.
 
     Currently returns the rescaled length of the interval. If one of the
@@ -71,7 +62,7 @@ def default_loss(
 
 
 @uses_nth_neighbors(1)
-def triangle_loss(xs: Any, ys: Any) -> Union[np.float64, float]:
+def triangle_loss(xs: Any, ys: Any) -> Union[float, float]:
     xs = [x for x in xs if x is not None]
     ys = [y for y in ys if y is not None]
 
@@ -110,10 +101,8 @@ def curvature_loss(xs, ys):
 
 
 def linspace(
-    x_left: Union[int, np.float64, float],
-    x_right: Union[int, np.float64, float],
-    n: int,
-) -> Union[List[float], List[np.float64]]:
+    x_left: Union[int, float, float], x_right: Union[int, float, float], n: int,
+) -> Union[List[float], List[float]]:
     """This is equivalent to
     'np.linspace(x_left, x_right, n, endpoint=False)[1:]',
     but it is 15-30 times faster for small 'n'."""
@@ -136,7 +125,7 @@ def _get_neighbors_from_list(xs: np.ndarray) -> SortedDict:
 
 
 def _get_intervals(
-    x: Union[int, np.float64, float], neighbors: SortedDict, nth_neighbors: int
+    x: Union[int, float, float], neighbors: SortedDict, nth_neighbors: int
 ) -> Any:
     nn = nth_neighbors
     i = neighbors.index(x)
@@ -262,38 +251,36 @@ def npoints(self) -> int:
         return len(self.data)
 
     @cache_latest
-    def loss(self, real: bool = True) -> Union[int, np.float64, float]:
+    def loss(self, real: bool = True) -> Union[int, float, 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, np.float64]]
-    ) -> Optional[Union[float, np.float64]]:
+        self, x: Optional[Union[float, int, float]]
+    ) -> Optional[Union[float, float]]:
         if x is None:
             return None
         return x / self._scale[0]
 
     def _scale_y(
-        self, y: Optional[Union[int, np.ndarray, np.float64, float]]
-    ) -> Optional[Union[float, np.float64, np.ndarray]]:
+        self, y: Optional[Union[int, np.ndarray, float, float]]
+    ) -> Optional[Union[float, float, np.ndarray]]:
         if y is None:
             return None
         y_scale = self._scale[1] or 1
         return y / y_scale
 
-    def _get_point_by_index(self, ind: int) -> Optional[Union[int, np.float64, float]]:
+    def _get_point_by_index(self, ind: int) -> Optional[Union[int, float, float]]:
         if ind < 0 or ind >= len(self.neighbors):
             return None
         return self.neighbors.keys()[ind]
 
     def _get_loss_in_interval(
-        self,
-        x_left: Union[int, np.float64, float],
-        x_right: Union[int, np.float64, float],
-    ) -> Union[int, np.float64, float]:
+        self, x_left: Union[int, float, float], x_right: Union[int, float, float],
+    ) -> Union[int, float, float]:
         assert x_left is not None and x_right is not None
 
         if x_right - x_left < self._dx_eps:
@@ -314,9 +301,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, np.float64, float],
-        x_right: Union[int, np.float64, float],
+        self, x_left: Union[int, float, float], x_right: Union[int, float, float],
     ) -> None:
         if x_left is None or x_right is None:
             return
@@ -333,9 +318,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, np.float64, float], real: bool = True
-    ) -> None:
+    def _update_losses(self, x: Union[int, float, 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'.
@@ -378,7 +361,7 @@ def _update_losses(
             self.losses_combined[x, b] = float("inf")
 
     @staticmethod
-    def _find_neighbors(x: Union[int, np.float64, float], neighbors: SortedDict) -> Any:
+    def _find_neighbors(x: Union[int, float, float], neighbors: SortedDict) -> Any:
         if x in neighbors:
             return neighbors[x]
         pos = neighbors.bisect_left(x)
@@ -388,7 +371,7 @@ def _find_neighbors(x: Union[int, np.float64, float], neighbors: SortedDict) ->
         return x_left, x_right
 
     def _update_neighbors(
-        self, x: Union[int, np.float64, float], neighbors: SortedDict
+        self, x: Union[int, float, float], neighbors: SortedDict
     ) -> None:
         if x not in neighbors:  # The point is new
             x_left, x_right = self._find_neighbors(x, neighbors)
@@ -397,9 +380,7 @@ def _update_neighbors(
             neighbors.get(x_right, [None, None])[0] = x
 
     def _update_scale(
-        self,
-        x: Union[int, np.float64, float],
-        y: Union[float, int, np.float64, np.ndarray],
+        self, x: Union[int, float, float], y: Union[float, int, float, np.ndarray],
     ) -> None:
         """Update the scale with which the x and y-values are scaled.
 
@@ -427,7 +408,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, np.float64, float], y: Any) -> None:
+    def tell(self, x: Union[int, float, float], y: Any) -> None:
         if x in self.data:
             # The point is already evaluated before
             return
@@ -462,7 +443,7 @@ def tell(self, x: Union[int, np.float64, float], y: Any) -> None:
 
             self._oldscale = deepcopy(self._scale)
 
-    def tell_pending(self, x: Union[int, np.float64, float]) -> None:
+    def tell_pending(self, x: Union[int, float, float]) -> None:
         if x in self.data:
             # The point is already evaluated before
             return
@@ -678,7 +659,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, np.float64, float]) -> ItemSortedDict:
+def loss_manager(x_scale: Union[int, float, float]) -> ItemSortedDict:
     def sort_key(ival, loss):
         loss, ival = finite_loss(ival, loss, x_scale)
         return -loss, ival
@@ -688,9 +669,7 @@ def sort_key(ival, loss):
 
 
 def finite_loss(
-    ival: Any,
-    loss: Union[int, np.float64, float],
-    x_scale: Union[int, np.float64, float],
+    ival: Any, loss: Union[int, float, float], x_scale: Union[int, float, float],
 ) -> Any:
     """Get the socalled finite_loss of an interval in order to be able to
     sort intervals that have infinite loss."""

adaptive/learner/learner2D.py

@@ -538,9 +538,9 @@ def inside_bounds(
         self,
         xy: Union[
             Tuple[int, int],
-            Tuple[np.float64, float],
-            Tuple[np.float64, np.float64],
-            Tuple[float, np.float64],
+            Tuple[float, float],
+            Tuple[float, float],
+            Tuple[float, float],
         ],
     ) -> Union[bool, np.bool_]:
         x, y = xy
@@ -551,11 +551,11 @@ def tell(
         self,
         point: Union[
             Tuple[int, int],
-            Tuple[np.float64, float],
-            Tuple[np.float64, np.float64],
-            Tuple[float, np.float64],
+            Tuple[float, float],
+            Tuple[float, float],
+            Tuple[float, float],
         ],
-        value: Union[List[int], np.float64, float],
+        value: Union[List[int], float, float],
     ) -> None:
         point = tuple(point)
         self.data[point] = value
@@ -569,9 +569,9 @@ def tell_pending(
         self,
         point: Union[
             Tuple[int, int],
-            Tuple[np.float64, float],
-            Tuple[np.float64, np.float64],
-            Tuple[float, np.float64],
+            Tuple[float, float],
+            Tuple[float, float],
+            Tuple[float, float],
         ],
     ) -> None:
         point = tuple(point)
@@ -584,25 +584,13 @@ def tell_pending(
     def _fill_stack(
         self, stack_till: int = 1
     ) -> Union[
-        Tuple[List[Tuple[np.float64, np.float64]], List[np.float64]],
+        Tuple[List[Tuple[float, float]], List[float]],
         Tuple[
-            List[
-                Union[
-                    Tuple[np.float64, np.float64],
-                    Tuple[float, np.float64],
-                    Tuple[np.float64, float],
-                ]
-            ],
-            List[np.float64],
-        ],
-        Tuple[
-            List[Union[Tuple[float, np.float64], Tuple[np.float64, np.float64]]],
-            List[np.float64],
-        ],
-        Tuple[
-            List[Union[Tuple[np.float64, np.float64], Tuple[np.float64, float]]],
-            List[np.float64],
+            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]],
     ]:
         if len(self.data) + len(self.pending_points) < self.ndim + 1:
             raise ValueError("too few points...")
@@ -673,7 +661,7 @@ def ask(self, n: int, tell_pending: bool = True) -> Any:
         return points[:n], loss_improvements[:n]
 
     @cache_latest
-    def loss(self, real: bool = True) -> np.float64:
+    def loss(self, real: bool = True) -> float:
         if not self.bounds_are_done:
             return np.inf
         ip = self.interpolator(scaled=True) if real else self._interpolator_combined()