Update data types to float for direction angles and vectors

Author: yemeen

src/ect/directions.py

@@ -16,7 +16,7 @@ class Directions:
     Supports uniform, random, or custom sampling of directions.
 
     **Examples:**
-    
+
     .. code-block:: python
 
         # Uniform sampling in 2D (default)
@@ -57,15 +57,15 @@ def __init__(
             - For 2D, directions are represented as angles; for higher dimensions, as unit vectors.
             - Use factory methods :meth:`uniform`, :meth:`random`, :meth:`from_angles`, or :meth:`from_vectors` for convenience.
         """
-        
+
         self.num_dirs = num_dirs
         self.sampling = sampling
         self.dim = dim
         self.endpoint = endpoint
 
         self._rng = np.random.RandomState(seed)
-        self._thetas = None
-        self._vectors = None
+        self._thetas: Optional[np.ndarray] = None
+        self._vectors: Optional[np.ndarray] = None
         self._initialize_directions()
 
     def _initialize_directions(self):
@@ -82,16 +82,14 @@ def _initialize_directions(self):
             else:
                 # generate random normal samples and normalize to lie on the unit sphere
                 self._vectors = self._rng.randn(self.num_dirs, self.dim)
-                self._vectors /= np.linalg.norm(self._vectors,
-                                                axis=1, keepdims=True)
+                self._vectors /= np.linalg.norm(self._vectors, axis=1, keepdims=True)
         elif self.sampling == Sampling.RANDOM:
             if self.dim == 2:
                 self._thetas = self._rng.uniform(0, 2 * np.pi, self.num_dirs)
                 self._thetas.sort()
             else:
                 self._vectors = self._rng.randn(self.num_dirs, self.dim)
-                self._vectors /= np.linalg.norm(self._vectors,
-                                                axis=1, keepdims=True)
+                self._vectors /= np.linalg.norm(self._vectors, axis=1, keepdims=True)
 
     @classmethod
     def uniform(
@@ -142,11 +140,11 @@ def from_angles(cls, angles: Sequence[float]) -> "Directions":
             - Angles are stored in :attr:`thetas` and unit vectors are computed as needed.
         """
         instance = cls(len(angles), Sampling.CUSTOM, dim=2)
-        instance._thetas = np.array(angles)
+        instance._thetas = np.array(angles, dtype=float)
         return instance
 
     @classmethod
-    def from_vectors(cls, vectors: Sequence[tuple]) -> "Directions":
+    def from_vectors(cls, vectors: Sequence[Sequence[float]]) -> "Directions":
         """
         Create a Directions instance from custom direction vectors in any dimension.
 
@@ -163,12 +161,12 @@ def from_vectors(cls, vectors: Sequence[tuple]) -> "Directions":
             - Vectors are normalized to unit length.
             - For 2D, angles are computed from the vectors and available via :attr:`thetas`.
         """
-        vectors = np.array(vectors, dtype=float)
-        norms = np.linalg.norm(vectors, axis=1, keepdims=True)
+        vectors_arr = np.array(vectors, dtype=float)
+        norms = np.linalg.norm(vectors_arr, axis=1, keepdims=True)
         if np.any(norms == 0):
             raise ValueError("Zero-magnitude vectors are not allowed")
-        normalized = vectors / norms
-        instance = cls(len(vectors), Sampling.CUSTOM, dim=vectors.shape[1])
+        normalized = vectors_arr / norms
+        instance = cls(len(vectors_arr), Sampling.CUSTOM, dim=vectors_arr.shape[1])
         instance._vectors = normalized
         if instance.dim == 2:
             instance._thetas = np.arctan2(normalized[:, 1], normalized[:, 0])
@@ -196,6 +194,7 @@ def thetas(self) -> np.ndarray:
         if self._thetas is None:
             # Compute the angles from the vectors.
             self._thetas = np.arctan2(self.vectors[:, 1], self.vectors[:, 0])
+        assert self._thetas is not None
         return self._thetas
 
     @property
@@ -215,13 +214,15 @@ def vectors(self) -> np.ndarray:
         """
         if self._vectors is None:
             if self.dim == 2:
-                self._vectors = np.column_stack(
-                    (np.cos(self._thetas), np.sin(self._thetas))
-                )
+                thetas = self._thetas
+                if thetas is None:
+                    raise ValueError("2D direction angles are not initialized.")
+                self._vectors = np.column_stack((np.cos(thetas), np.sin(thetas)))
             else:
                 raise ValueError(
                     "Direction vectors for dimensions >2 should be generated during initialization."
                 )
+        assert self._vectors is not None
         return self._vectors
 
     def __len__(self) -> int:

src/ect/sect.py

@@ -2,7 +2,7 @@
 from .embed_complex import EmbeddedComplex
 from .directions import Directions
 from .results import ECTResult
-from typing import Optional, Union
+from typing import Optional
 import numpy as np
 
 

src/ect/validation/base.py

@@ -81,7 +81,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """
         Validate a cell against this rule.

src/ect/validation/rules.py

@@ -40,7 +40,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate that dimension is non-negative."""
         if dim is not None and dim < 0:
@@ -68,7 +68,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate vertex count matches cell dimension requirements."""
         if dim is None:
@@ -114,7 +114,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate coordinate dimensions are consistent."""
         if self.dimension_checker is None or cell_coords is None:
@@ -156,7 +156,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate that no other vertices lie on this edge's interior."""
         is_valid, error_msg = validate_edge_embedding(
@@ -185,7 +185,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate that no other vertices lie inside this face."""
         is_valid, error_msg = validate_face_embedding(
@@ -214,7 +214,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate that face edges don't intersect each other"""
 
@@ -275,7 +275,7 @@ def validate(
         all_coords: np.ndarray,
         cell_indices: List[int],
         all_indices: List[int],
-        dim: int = None,
+        dim: Optional[int] = None,
     ) -> ValidationResult:
         """Validate that all boundary edges exist for this face."""
         if self.edge_checker is None: