type hint fixes for adaptive/learner/triangulation.py

Author: basnijholt

adaptive/learner/triangulation.py

@@ -3,14 +3,15 @@
 from collections.abc import Iterable, Sized
 from itertools import chain, combinations
 from math import factorial
-from typing import Any, Iterator, List, Optional, Set, Tuple, Union
+from typing import Any, Iterator, List, Optional, Sequence, Set, Tuple, Union
 
 import numpy as np
 import scipy.spatial
-from numpy import int32
 
+Simplex = Tuple[int, ...]  # XXX: check if this is correct
 
-def fast_norm(v: Union[Tuple[float, float, float], np.ndarray]) -> float:
+
+def fast_norm(v: Union[Tuple[float, ...], np.ndarray]) -> float:
     # notice this method can be even more optimised
     if len(v) == 2:
         return math.sqrt(v[0] * v[0] + v[1] * v[1])
@@ -20,12 +21,8 @@ def fast_norm(v: Union[Tuple[float, float, float], np.ndarray]) -> float:
 
 
 def fast_2d_point_in_simplex(
-    point: Union[Tuple[int, int], Tuple[float, float], Tuple[float, float]],
-    simplex: Union[
-        List[Union[Tuple[int, int], Tuple[float, float]]],
-        List[Tuple[float, float]],
-        np.ndarray,
-    ],
+    point: Tuple[float, ...],
+    simplex: Union[List[Tuple[float, ...]], np.ndarray],
     eps: float = 1e-8,
 ) -> Union[bool, np.bool_]:
     (p0x, p0y), (p1x, p1y), (p2x, p2y) = simplex
@@ -42,7 +39,7 @@ def fast_2d_point_in_simplex(
 
 
 def point_in_simplex(
-    point: Any, simplex: Any, eps: float = 1e-8
+    point: Any, simplex: Simplex, eps: float = 1e-8
 ) -> Union[bool, np.bool_]:
     if len(point) == 2:
         return fast_2d_point_in_simplex(point, simplex, eps)
@@ -143,13 +140,7 @@ def fast_det(matrix: np.ndarray) -> float:
         return np.linalg.det(matrix)
 
 
-def circumsphere(
-    pts: np.ndarray,
-) -> Union[
-    Tuple[Tuple[float, float, float, float], float],
-    Tuple[Tuple[float, float], float],
-    Tuple[Tuple[float, float, float], float],
-]:
+def circumsphere(pts: np.ndarray,) -> Tuple[Tuple[float, ...], float]:
     dim = len(pts) - 1
     if dim == 2:
         return fast_2d_circumcircle(pts)
@@ -175,7 +166,7 @@ def circumsphere(
     return tuple(center), radius
 
 
-def orientation(face: Any, origin: Any) -> Union[int, float]:
+def orientation(face: np.ndarray, origin: np.ndarray) -> int:
     """Compute the orientation of the face with respect to a point, origin.
 
     Parameters
@@ -205,14 +196,7 @@ def is_iterable_and_sized(obj: Any) -> bool:
     return isinstance(obj, Iterable) and isinstance(obj, Sized)
 
 
-def simplex_volume_in_embedding(
-    vertices: Union[
-        List[Tuple[float, float, float]],
-        List[Tuple[float, float, float]],
-        List[Tuple[float, float, float, float]],
-        List[Tuple[float, float, float, float, float]],
-    ]
-) -> float:
+def simplex_volume_in_embedding(vertices: List[Tuple[float, ...]]) -> float:
     """Calculate the volume of a simplex in a higher dimensional embedding.
     That is: dim > len(vertices) - 1. For example if you would like to know the
     surface area of a triangle in a 3d space.
@@ -293,7 +277,7 @@ class Triangulation:
         or more simplices in the
     """
 
-    def __init__(self, coords: Any) -> None:
+    def __init__(self, coords: np.ndarray) -> None:
         if not is_iterable_and_sized(coords):
             raise TypeError("Please provide a 2-dimensional list of points")
         coords = list(coords)
@@ -332,27 +316,29 @@ def __init__(self, coords: Any) -> None:
         for simplex in initial_tri.simplices:
             self.add_simplex(simplex)
 
-    def delete_simplex(self, simplex: Any) -> None:
+    def delete_simplex(self, simplex: Simplex) -> None:
         simplex = tuple(sorted(simplex))
         self.simplices.remove(simplex)
         for vertex in simplex:
             self.vertex_to_simplices[vertex].remove(simplex)
 
-    def add_simplex(self, simplex: Any) -> None:
+    def add_simplex(self, simplex: Simplex) -> None:
         simplex = tuple(sorted(simplex))
         self.simplices.add(simplex)
         for vertex in simplex:
             self.vertex_to_simplices[vertex].add(simplex)
 
-    def get_vertices(self, indices: Any) -> Any:
+    def get_vertices(self, indices: Sequence[int]) -> Any:
         return [self.get_vertex(i) for i in indices]
 
-    def get_vertex(self, index: Optional[Union[int32, int]]) -> Any:
+    def get_vertex(self, index: Optional[int]) -> Any:
         if index is None:
             return None
         return self.vertices[index]
 
-    def get_reduced_simplex(self, point: Any, simplex: Any, eps: float = 1e-8) -> list:
+    def get_reduced_simplex(
+        self, point: Any, simplex: Simplex, eps: float = 1e-8
+    ) -> list:
         """Check whether vertex lies within a simplex.
 
         Returns
@@ -378,7 +364,7 @@ def get_reduced_simplex(self, point: Any, simplex: Any, eps: float = 1e-8) -> li
         return [simplex[i] for i in result]
 
     def point_in_simplex(
-        self, point: Any, simplex: Any, eps: float = 1e-8
+        self, point: Any, simplex: Simplex, eps: float = 1e-8
     ) -> Union[bool, np.bool_]:
         vertices = self.get_vertices(simplex)
         return point_in_simplex(point, vertices, eps)
@@ -466,12 +452,8 @@ def _extend_hull(self, new_vertex: Any, eps: float = 1e-8) -> Any:
         return new_simplices
 
     def circumscribed_circle(
-        self, simplex: Any, transform: np.ndarray
-    ) -> Union[
-        Tuple[Tuple[float, float, float, float], float],
-        Tuple[Tuple[float, float], float],
-        Tuple[Tuple[float, float, float], float],
-    ]:
+        self, simplex: Simplex, transform: np.ndarray
+    ) -> Tuple[Tuple[float, ...], float]:
         """Compute the center and radius of the circumscribed circle of a simplex.
 
         Parameters
@@ -488,7 +470,7 @@ def circumscribed_circle(
         return circumsphere(pts)
 
     def point_in_cicumcircle(
-        self, pt_index: int, simplex: Any, transform: np.ndarray
+        self, pt_index: int, simplex: Simplex, transform: np.ndarray
     ) -> np.bool_:
         # return self.fast_point_in_circumcircle(pt_index, simplex, transform)
         eps = 1e-8
@@ -567,10 +549,10 @@ def bowyer_watson(
         new_triangles = self.vertex_to_simplices[pt_index]
         return bad_triangles - new_triangles, new_triangles - bad_triangles
 
-    def _simplex_is_almost_flat(self, simplex: Any) -> np.bool_:
+    def _simplex_is_almost_flat(self, simplex: Simplex) -> np.bool_:
         return self._relative_volume(simplex) < 1e-8
 
-    def _relative_volume(self, simplex: Any) -> float:
+    def _relative_volume(self, simplex: Simplex) -> float:
         """Compute the volume of a simplex divided by the average (Manhattan)
         distance of its vertices. The advantage of this is that the relative
         volume is only dependent on the shape of the simplex and not on the
@@ -635,7 +617,7 @@ def add_point(
             self.vertices.append(point)
             return self.bowyer_watson(pt_index, actual_simplex, transform)
 
-    def volume(self, simplex: Any) -> float:
+    def volume(self, simplex: Simplex) -> float:
         prefactor = np.math.factorial(self.dim)
         vertices = np.array(self.get_vertices(simplex))
         vectors = vertices[1:] - vertices[0]
@@ -658,10 +640,10 @@ def vertex_invariant(self, vertex):
         """Simplices originating from a vertex don't overlap."""
         raise NotImplementedError
 
-    def get_neighbors_from_vertices(self, simplex: Any) -> Any:
+    def get_neighbors_from_vertices(self, simplex: Simplex) -> Any:
         return set.union(*[self.vertex_to_simplices[p] for p in simplex])
 
-    def get_face_sharing_neighbors(self, neighbors: Any, simplex: Any) -> Any:
+    def get_face_sharing_neighbors(self, neighbors: Any, simplex: Simplex) -> Any:
         """Keep only the simplices sharing a whole face with simplex."""
         return {
             simpl for simpl in neighbors if len(set(simpl) & set(simplex)) == self.dim
@@ -672,15 +654,7 @@ def get_simplices_attached_to_points(self, indices: Any) -> Any:
         neighbors = self.get_neighbors_from_vertices(indices)
         return self.get_face_sharing_neighbors(neighbors, indices)
 
-    def get_opposing_vertices(
-        self,
-        simplex: Union[
-            Tuple[int32, int, int],
-            Tuple[int32, int32, int],
-            Tuple[int32, int32, int32],
-            Tuple[int, int, int],
-        ],
-    ) -> Any:
+    def get_opposing_vertices(self, simplex: Simplex,) -> Any:
         if simplex not in self.simplices:
             raise ValueError("Provided simplex is not part of the triangulation")
         neighbors = self.get_simplices_attached_to_points(simplex)
@@ -698,7 +672,7 @@ def find_opposing_vertex(vertex):
         return result
 
     @property
-    def hull(self) -> Union[Set[int32], Set[int], Set[Union[int32, int]]]:
+    def hull(self) -> Set[int]:
         """Compute hull from triangulation.
 
         Parameters