nrl-tracker 0.21.5__py3-none-any.whl → 0.22.0__py3-none-any.whl

pytcl/coordinate_systems/jacobians/__init__.py

@@ -10,18 +10,16 @@ This module provides:
 - Covariance transformation utilities
 """
 
-from pytcl.coordinate_systems.jacobians.jacobians import (
-    cross_covariance_transform,
-    enu_jacobian,
-    geodetic_jacobian,
-    ned_jacobian,
-    numerical_jacobian,
-    polar_jacobian,
-    polar_jacobian_inv,
-    ruv_jacobian,
-    spherical_jacobian,
-    spherical_jacobian_inv,
-)
+from pytcl.coordinate_systems.jacobians.jacobians import cross_covariance_transform
+from pytcl.coordinate_systems.jacobians.jacobians import enu_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import geodetic_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import ned_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import numerical_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import polar_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import polar_jacobian_inv
+from pytcl.coordinate_systems.jacobians.jacobians import ruv_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import spherical_jacobian
+from pytcl.coordinate_systems.jacobians.jacobians import spherical_jacobian_inv
 
 __all__ = [
     "spherical_jacobian",

pytcl/coordinate_systems/jacobians/jacobians.py

@@ -9,7 +9,8 @@ filters (e.g., converting measurement covariances between coordinate systems).
 from typing import Literal
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def spherical_jacobian(

pytcl/coordinate_systems/projections/__init__.py

@@ -26,32 +26,36 @@ Examples
 ...                         result.zone, result.hemisphere)
 """
 
-from pytcl.coordinate_systems.projections.projections import (  # Constants; Result types; Azimuthal Equidistant; UTM; Lambert Conformal Conic; Mercator; Stereographic; Transverse Mercator
-    WGS84_A,
-    WGS84_B,
-    WGS84_E,
-    WGS84_E2,
-    WGS84_EP2,
-    WGS84_F,
-    ProjectionResult,
-    UTMResult,
-    azimuthal_equidistant,
+from pytcl.coordinate_systems.projections.projections import (
+    WGS84_A,  # Constants; Result types; Azimuthal Equidistant; UTM; Lambert Conformal Conic; Mercator; Stereographic; Transverse Mercator
+)
+from pytcl.coordinate_systems.projections.projections import WGS84_B
+from pytcl.coordinate_systems.projections.projections import WGS84_E
+from pytcl.coordinate_systems.projections.projections import WGS84_E2
+from pytcl.coordinate_systems.projections.projections import WGS84_EP2
+from pytcl.coordinate_systems.projections.projections import WGS84_F
+from pytcl.coordinate_systems.projections.projections import ProjectionResult
+from pytcl.coordinate_systems.projections.projections import UTMResult
+from pytcl.coordinate_systems.projections.projections import azimuthal_equidistant
+from pytcl.coordinate_systems.projections.projections import (
     azimuthal_equidistant_inverse,
-    geodetic2utm,
-    geodetic2utm_batch,
-    lambert_conformal_conic,
+)
+from pytcl.coordinate_systems.projections.projections import geodetic2utm
+from pytcl.coordinate_systems.projections.projections import geodetic2utm_batch
+from pytcl.coordinate_systems.projections.projections import lambert_conformal_conic
+from pytcl.coordinate_systems.projections.projections import (
     lambert_conformal_conic_inverse,
-    mercator,
-    mercator_inverse,
-    polar_stereographic,
-    stereographic,
-    stereographic_inverse,
-    transverse_mercator,
-    transverse_mercator_inverse,
-    utm2geodetic,
-    utm_central_meridian,
-    utm_zone,
 )
+from pytcl.coordinate_systems.projections.projections import mercator
+from pytcl.coordinate_systems.projections.projections import mercator_inverse
+from pytcl.coordinate_systems.projections.projections import polar_stereographic
+from pytcl.coordinate_systems.projections.projections import stereographic
+from pytcl.coordinate_systems.projections.projections import stereographic_inverse
+from pytcl.coordinate_systems.projections.projections import transverse_mercator
+from pytcl.coordinate_systems.projections.projections import transverse_mercator_inverse
+from pytcl.coordinate_systems.projections.projections import utm2geodetic
+from pytcl.coordinate_systems.projections.projections import utm_central_meridian
+from pytcl.coordinate_systems.projections.projections import utm_zone
 
 __all__ = [
     # Constants

pytcl/coordinate_systems/projections/projections.py

@@ -25,7 +25,9 @@ References
        nanometers." Journal of Geodesy 85.8 (2011): 475-485.
 """
 
-from typing import NamedTuple, Optional, Tuple
+from typing import NamedTuple
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -140,9 +142,7 @@ def mercator(
 
     # Northing using isometric latitude
     sin_lat = np.sin(lat)
-    y = a * np.log(
-        np.tan(np.pi / 4 + lat / 2) * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2)
-    )
+    y = a * np.log(np.tan(np.pi / 4 + lat / 2) * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2))
 
     # Scale factor
     cos_lat = np.cos(lat)
@@ -203,9 +203,7 @@ def mercator_inverse(
 
     for _ in range(max_iter):
         sin_lat = np.sin(lat)
-        lat_new = np.pi / 2 - 2 * np.arctan(
-            t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2)
-        )
+        lat_new = np.pi / 2 - 2 * np.arctan(t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2))
         if abs(lat_new - lat) < tol:
             break
         lat = lat_new
@@ -583,9 +581,7 @@ def geodetic2utm(lat: float, lon: float, zone: Optional[int] = None) -> UTMResul
         northing = result.y + 10000000.0
         hemisphere = "S"
 
-    return UTMResult(
-        easting, northing, zone, hemisphere, result.scale, result.convergence
-    )
+    return UTMResult(easting, northing, zone, hemisphere, result.scale, result.convergence)
 
 
 def utm2geodetic(
@@ -696,8 +692,7 @@ def stereographic(
         return (
             2
             * np.arctan(
-                np.tan(np.pi / 4 + phi / 2)
-                * ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
+                np.tan(np.pi / 4 + phi / 2) * ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
             )
             - np.pi / 2
         )
@@ -785,8 +780,7 @@ def stereographic_inverse(
     chi0 = (
         2
         * np.arctan(
-            np.tan(np.pi / 4 + lat0 / 2)
-            * ((1 - e * sin_lat0) / (1 + e * sin_lat0)) ** (e / 2)
+            np.tan(np.pi / 4 + lat0 / 2) * ((1 - e * sin_lat0) / (1 + e * sin_lat0)) ** (e / 2)
         )
         - np.pi / 2
     )
@@ -821,8 +815,7 @@ def stereographic_inverse(
         lat_new = (
             2
             * np.arctan(
-                np.tan(np.pi / 4 + chi / 2)
-                * ((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2)
+                np.tan(np.pi / 4 + chi / 2) * ((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2)
             )
             - np.pi / 2
         )
@@ -954,9 +947,7 @@ def lambert_conformal_conic(
 
     def compute_t(phi: float) -> float:
         sin_phi = np.sin(phi)
-        return np.tan(np.pi / 4 - phi / 2) / (
-            ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
-        )
+        return np.tan(np.pi / 4 - phi / 2) / (((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2))
 
     m1 = compute_m(lat1)
     m2 = compute_m(lat2)
@@ -1045,9 +1036,7 @@ def lambert_conformal_conic_inverse(
 
     def compute_t(phi: float) -> float:
         sin_phi = np.sin(phi)
-        return np.tan(np.pi / 4 - phi / 2) / (
-            ((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2)
-        )
+        return np.tan(np.pi / 4 - phi / 2) / (((1 - e * sin_phi) / (1 + e * sin_phi)) ** (e / 2))
 
     m1 = compute_m(lat1)
     m2 = compute_m(lat2)
@@ -1075,9 +1064,7 @@ def lambert_conformal_conic_inverse(
     lat = np.pi / 2 - 2 * np.arctan(t)
     for _ in range(max_iter):
         sin_lat = np.sin(lat)
-        lat_new = np.pi / 2 - 2 * np.arctan(
-            t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2)
-        )
+        lat_new = np.pi / 2 - 2 * np.arctan(t * ((1 - e * sin_lat) / (1 + e * sin_lat)) ** (e / 2))
         if abs(lat_new - lat) < tol:
             break
         lat = lat_new
@@ -1141,13 +1128,7 @@ def azimuthal_equidistant(
     """
     # Use spherical approximation with authalic radius
     R = a * np.sqrt(
-        (
-            1
-            + (1 - e2)
-            / (2 * np.sqrt(1 - e2))
-            * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))
-        )
-        / 2
+        (1 + (1 - e2) / (2 * np.sqrt(1 - e2)) * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))) / 2
     )
 
     sin_lat = np.sin(lat)
@@ -1217,13 +1198,7 @@ def azimuthal_equidistant_inverse(
         (latitude, longitude) in radians.
     """
     R = a * np.sqrt(
-        (
-            1
-            + (1 - e2)
-            / (2 * np.sqrt(1 - e2))
-            * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))
-        )
-        / 2
+        (1 + (1 - e2) / (2 * np.sqrt(1 - e2)) * np.log((1 + np.sqrt(1 - e2)) / np.sqrt(e2))) / 2
     )
 
     rho = np.sqrt(x**2 + y**2)

pytcl/coordinate_systems/rotations/__init__.py

@@ -9,28 +9,26 @@ This module provides:
 - Rotation interpolation (SLERP)
 """
 
-from pytcl.coordinate_systems.rotations.rotations import (
-    axisangle2rotmat,
-    dcm_rate,
-    euler2quat,
-    euler2rotmat,
-    is_rotation_matrix,
-    quat2euler,
-    quat2rotmat,
-    quat_conjugate,
-    quat_inverse,
-    quat_multiply,
-    quat_rotate,
-    rodrigues2rotmat,
-    rotmat2axisangle,
-    rotmat2euler,
-    rotmat2quat,
-    rotmat2rodrigues,
-    rotx,
-    roty,
-    rotz,
-    slerp,
-)
+from pytcl.coordinate_systems.rotations.rotations import axisangle2rotmat
+from pytcl.coordinate_systems.rotations.rotations import dcm_rate
+from pytcl.coordinate_systems.rotations.rotations import euler2quat
+from pytcl.coordinate_systems.rotations.rotations import euler2rotmat
+from pytcl.coordinate_systems.rotations.rotations import is_rotation_matrix
+from pytcl.coordinate_systems.rotations.rotations import quat2euler
+from pytcl.coordinate_systems.rotations.rotations import quat2rotmat
+from pytcl.coordinate_systems.rotations.rotations import quat_conjugate
+from pytcl.coordinate_systems.rotations.rotations import quat_inverse
+from pytcl.coordinate_systems.rotations.rotations import quat_multiply
+from pytcl.coordinate_systems.rotations.rotations import quat_rotate
+from pytcl.coordinate_systems.rotations.rotations import rodrigues2rotmat
+from pytcl.coordinate_systems.rotations.rotations import rotmat2axisangle
+from pytcl.coordinate_systems.rotations.rotations import rotmat2euler
+from pytcl.coordinate_systems.rotations.rotations import rotmat2quat
+from pytcl.coordinate_systems.rotations.rotations import rotmat2rodrigues
+from pytcl.coordinate_systems.rotations.rotations import rotx
+from pytcl.coordinate_systems.rotations.rotations import roty
+from pytcl.coordinate_systems.rotations.rotations import rotz
+from pytcl.coordinate_systems.rotations.rotations import slerp
 
 __all__ = [
     "rotx",

pytcl/coordinate_systems/rotations/rotations.py

@@ -10,7 +10,8 @@ from typing import Tuple
 
 import numpy as np
 from numba import njit
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 @njit(cache=True, fastmath=True)
@@ -353,9 +354,7 @@ def rotmat2axisangle(
         return axis / np.linalg.norm(axis), float(angle)
 
     # General case
-    axis = np.array([R[2, 1] - R[1, 2], R[0, 2] - R[2, 0], R[1, 0] - R[0, 1]]) / (
-        2 * np.sin(angle)
-    )
+    axis = np.array([R[2, 1] - R[1, 2], R[0, 2] - R[2, 0], R[1, 0] - R[0, 1]]) / (2 * np.sin(angle))
 
     return axis, float(angle)
 

pytcl/core/__init__.py

@@ -7,28 +7,22 @@ This module provides foundational functionality used throughout the library:
 - Array manipulation helpers compatible with MATLAB conventions
 """
 
-from pytcl.core.array_utils import (
-    column_vector,
-    row_vector,
-    wrap_to_2pi,
-    wrap_to_pi,
-    wrap_to_range,
-)
-from pytcl.core.constants import (
-    EARTH_FLATTENING,
-    EARTH_ROTATION_RATE,
-    EARTH_SEMI_MAJOR_AXIS,
-    GRAVITATIONAL_CONSTANT,
-    SPEED_OF_LIGHT,
-    WGS84,
-    PhysicalConstants,
-)
-from pytcl.core.validation import (
-    ensure_2d,
-    ensure_column_vector,
-    ensure_row_vector,
-    validate_array,
-)
+from pytcl.core.array_utils import column_vector
+from pytcl.core.array_utils import row_vector
+from pytcl.core.array_utils import wrap_to_2pi
+from pytcl.core.array_utils import wrap_to_pi
+from pytcl.core.array_utils import wrap_to_range
+from pytcl.core.constants import EARTH_FLATTENING
+from pytcl.core.constants import EARTH_ROTATION_RATE
+from pytcl.core.constants import EARTH_SEMI_MAJOR_AXIS
+from pytcl.core.constants import GRAVITATIONAL_CONSTANT
+from pytcl.core.constants import SPEED_OF_LIGHT
+from pytcl.core.constants import WGS84
+from pytcl.core.constants import PhysicalConstants
+from pytcl.core.validation import ensure_2d
+from pytcl.core.validation import ensure_column_vector
+from pytcl.core.validation import ensure_row_vector
+from pytcl.core.validation import validate_array
 
 __all__ = [
     # Constants

pytcl/core/array_utils.py

@@ -7,12 +7,15 @@ making it easier to port algorithms while maintaining Pythonic interfaces.
 
 from __future__ import annotations
 
-from typing import Any, Literal
+from typing import Any
+from typing import Literal
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
-from pytcl.core.constants import PI, TWO_PI
+from pytcl.core.constants import PI
+from pytcl.core.constants import TWO_PI
 
 
 def wrap_to_pi(angle: ArrayLike) -> NDArray[np.floating[Any]]:
@@ -374,10 +377,7 @@ def normalize_vector(
     v: ArrayLike,
     axis: int | None = None,
     return_norm: bool = False,
-) -> (
-    NDArray[np.floating[Any]]
-    | tuple[NDArray[np.floating[Any]], NDArray[np.floating[Any]]]
-):
+) -> NDArray[np.floating[Any]] | tuple[NDArray[np.floating[Any]], NDArray[np.floating[Any]]]:
     """
     Normalize vector(s) to unit length.
 

pytcl/core/constants.py

@@ -71,9 +71,7 @@ EARTH_ECCENTRICITY_SQ: Final[float] = 2 * EARTH_FLATTENING - EARTH_FLATTENING**2
 EARTH_ECCENTRICITY: Final[float] = math.sqrt(EARTH_ECCENTRICITY_SQ)
 
 #: Second eccentricity squared
-EARTH_ECCENTRICITY_PRIME_SQ: Final[float] = EARTH_ECCENTRICITY_SQ / (
-    1 - EARTH_ECCENTRICITY_SQ
-)
+EARTH_ECCENTRICITY_PRIME_SQ: Final[float] = EARTH_ECCENTRICITY_SQ / (1 - EARTH_ECCENTRICITY_SQ)
 
 #: Earth rotation rate [rad/s] (IERS Conventions 2010)
 EARTH_ROTATION_RATE: Final[float] = 7.292115e-5

pytcl/core/validation.py

@@ -9,10 +9,15 @@ messages when inputs don't meet requirements.
 from __future__ import annotations
 
 from functools import wraps
-from typing import Any, Callable, Literal, Sequence, TypeVar
+from typing import Any
+from typing import Callable
+from typing import Literal
+from typing import Sequence
+from typing import TypeVar
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 # Type variable for generic function signatures
 F = TypeVar("F", bound=Callable[..., Any])
@@ -108,9 +113,7 @@ def validate_array(
     if ndim is not None:
         valid_ndims = (ndim,) if isinstance(ndim, int) else ndim
         if result.ndim not in valid_ndims:
-            raise ValidationError(
-                f"{name} must have {ndim} dimension(s), got {result.ndim}"
-            )
+            raise ValidationError(f"{name} must have {ndim} dimension(s), got {result.ndim}")
 
     if min_ndim is not None and result.ndim < min_ndim:
         raise ValidationError(
@@ -125,14 +128,10 @@ def validate_array(
     # Check shape
     if shape is not None:
         if len(shape) != result.ndim:
-            raise ValidationError(
-                f"{name} must have {len(shape)} dimensions, got {result.ndim}"
-            )
+            raise ValidationError(f"{name} must have {len(shape)} dimensions, got {result.ndim}")
         for i, (expected, actual) in enumerate(zip(shape, result.shape)):
             if expected is not None and expected != actual:
-                raise ValidationError(
-                    f"{name} dimension {i} must be {expected}, got {actual}"
-                )
+                raise ValidationError(f"{name} dimension {i} must be {expected}, got {actual}")
 
     # Check finite
     if finite and not np.all(np.isfinite(result)):
@@ -259,9 +258,7 @@ def ensure_row_vector(arr: ArrayLike, name: str = "vector") -> NDArray[Any]:
         return result.reshape(1, -1)
     elif result.ndim == 2:
         if result.shape[0] != 1:
-            raise ValidationError(
-                f"{name} must be a row vector (1, n), got shape {result.shape}"
-            )
+            raise ValidationError(f"{name} must be a row vector (1, n), got shape {result.shape}")
         return result
     else:
         raise ValidationError(f"{name} must be 1D or 2D, got {result.ndim}D")
@@ -374,8 +371,7 @@ def ensure_positive_definite(
 
     if min_eigenvalue < threshold:
         raise ValidationError(
-            f"{name} must be positive definite, "
-            f"minimum eigenvalue is {min_eigenvalue:.2e}"
+            f"{name} must be positive definite, " f"minimum eigenvalue is {min_eigenvalue:.2e}"
         )
 
     return result
@@ -407,9 +403,7 @@ def validate_same_shape(*arrays: ArrayLike, names: Sequence[str] | None = None)
 
     if not all(s == shapes[0] for s in shapes):
         shape_strs = [f"{name}: {shape}" for name, shape in zip(names, shapes)]
-        raise ValidationError(
-            f"Arrays must have the same shape. Got: {', '.join(shape_strs)}"
-        )
+        raise ValidationError(f"Arrays must have the same shape. Got: {', '.join(shape_strs)}")
 
 
 def validated_array_input(

pytcl/dynamic_estimation/__init__.py

@@ -12,106 +12,97 @@ This module provides filtering and smoothing algorithms for state estimation:
 """
 
 # Import submodules for easy access
-from pytcl.dynamic_estimation import kalman, particle_filters
+from pytcl.dynamic_estimation import kalman
+from pytcl.dynamic_estimation import particle_filters
 
 # IMM estimator
-from pytcl.dynamic_estimation.imm import (
-    IMMEstimator,
-    IMMPrediction,
-    IMMState,
-    IMMUpdate,
-    imm_predict,
-    imm_predict_update,
-    imm_update,
-)
+from pytcl.dynamic_estimation.imm import IMMEstimator
+from pytcl.dynamic_estimation.imm import IMMPrediction
+from pytcl.dynamic_estimation.imm import IMMState
+from pytcl.dynamic_estimation.imm import IMMUpdate
+from pytcl.dynamic_estimation.imm import imm_predict
+from pytcl.dynamic_estimation.imm import imm_predict_update
+from pytcl.dynamic_estimation.imm import imm_update
 
 # Information filter
-from pytcl.dynamic_estimation.information_filter import (
-    InformationFilterResult,
-    InformationState,
-    SRIFResult,
-    SRIFState,
-    fuse_information,
-    information_filter,
-    information_to_state,
-    srif_filter,
-    srif_predict,
-    srif_update,
-    state_to_information,
-)
+from pytcl.dynamic_estimation.information_filter import InformationFilterResult
+from pytcl.dynamic_estimation.information_filter import InformationState
+from pytcl.dynamic_estimation.information_filter import SRIFResult
+from pytcl.dynamic_estimation.information_filter import SRIFState
+from pytcl.dynamic_estimation.information_filter import fuse_information
+from pytcl.dynamic_estimation.information_filter import information_filter
+from pytcl.dynamic_estimation.information_filter import information_to_state
+from pytcl.dynamic_estimation.information_filter import srif_filter
+from pytcl.dynamic_estimation.information_filter import srif_predict
+from pytcl.dynamic_estimation.information_filter import srif_update
+from pytcl.dynamic_estimation.information_filter import state_to_information
 
 # Square-root Kalman filters
 # Cubature Kalman filter
 # Unscented Kalman filter
 # Extended Kalman filter
 # Linear Kalman filter
-from pytcl.dynamic_estimation.kalman import (
-    KalmanPrediction,
-    KalmanState,
-    KalmanUpdate,
-    SigmaPoints,
-    SRKalmanPrediction,
-    SRKalmanState,
-    SRKalmanUpdate,
-    UDState,
-    ckf_predict,
-    ckf_spherical_cubature_points,
-    ckf_update,
-    ekf_predict,
-    ekf_predict_auto,
-    ekf_update,
-    ekf_update_auto,
-    information_filter_predict,
-    information_filter_update,
-    iterated_ekf_update,
-    kf_predict,
-    kf_predict_update,
-    kf_smooth,
-    kf_update,
-    numerical_jacobian,
-    sigma_points_julier,
-    sigma_points_merwe,
-    sr_ukf_predict,
-    sr_ukf_update,
-    srkf_predict,
-    srkf_predict_update,
-    srkf_update,
-    ud_factorize,
-    ud_predict,
-    ud_reconstruct,
-    ud_update,
-    ukf_predict,
-    ukf_update,
-    unscented_transform,
-)
+from pytcl.dynamic_estimation.kalman import KalmanPrediction
+from pytcl.dynamic_estimation.kalman import KalmanState
+from pytcl.dynamic_estimation.kalman import KalmanUpdate
+from pytcl.dynamic_estimation.kalman import SigmaPoints
+from pytcl.dynamic_estimation.kalman import SRKalmanPrediction
+from pytcl.dynamic_estimation.kalman import SRKalmanState
+from pytcl.dynamic_estimation.kalman import SRKalmanUpdate
+from pytcl.dynamic_estimation.kalman import UDState
+from pytcl.dynamic_estimation.kalman import ckf_predict
+from pytcl.dynamic_estimation.kalman import ckf_spherical_cubature_points
+from pytcl.dynamic_estimation.kalman import ckf_update
+from pytcl.dynamic_estimation.kalman import ekf_predict
+from pytcl.dynamic_estimation.kalman import ekf_predict_auto
+from pytcl.dynamic_estimation.kalman import ekf_update
+from pytcl.dynamic_estimation.kalman import ekf_update_auto
+from pytcl.dynamic_estimation.kalman import information_filter_predict
+from pytcl.dynamic_estimation.kalman import information_filter_update
+from pytcl.dynamic_estimation.kalman import iterated_ekf_update
+from pytcl.dynamic_estimation.kalman import kf_predict
+from pytcl.dynamic_estimation.kalman import kf_predict_update
+from pytcl.dynamic_estimation.kalman import kf_smooth
+from pytcl.dynamic_estimation.kalman import kf_update
+from pytcl.dynamic_estimation.kalman import numerical_jacobian
+from pytcl.dynamic_estimation.kalman import sigma_points_julier
+from pytcl.dynamic_estimation.kalman import sigma_points_merwe
+from pytcl.dynamic_estimation.kalman import sr_ukf_predict
+from pytcl.dynamic_estimation.kalman import sr_ukf_update
+from pytcl.dynamic_estimation.kalman import srkf_predict
+from pytcl.dynamic_estimation.kalman import srkf_predict_update
+from pytcl.dynamic_estimation.kalman import srkf_update
+from pytcl.dynamic_estimation.kalman import ud_factorize
+from pytcl.dynamic_estimation.kalman import ud_predict
+from pytcl.dynamic_estimation.kalman import ud_reconstruct
+from pytcl.dynamic_estimation.kalman import ud_update
+from pytcl.dynamic_estimation.kalman import ukf_predict
+from pytcl.dynamic_estimation.kalman import ukf_update
+from pytcl.dynamic_estimation.kalman import unscented_transform
 
 # Particle filters
-from pytcl.dynamic_estimation.particle_filters import (
-    ParticleState,
-    bootstrap_pf_predict,
-    bootstrap_pf_step,
-    bootstrap_pf_update,
-    effective_sample_size,
-    gaussian_likelihood,
-    initialize_particles,
-    particle_covariance,
-    particle_mean,
-    resample_multinomial,
-    resample_residual,
-    resample_systematic,
-)
+from pytcl.dynamic_estimation.particle_filters import ParticleState
+from pytcl.dynamic_estimation.particle_filters import bootstrap_pf_predict
+from pytcl.dynamic_estimation.particle_filters import bootstrap_pf_step
+from pytcl.dynamic_estimation.particle_filters import bootstrap_pf_update
+from pytcl.dynamic_estimation.particle_filters import effective_sample_size
+from pytcl.dynamic_estimation.particle_filters import gaussian_likelihood
+from pytcl.dynamic_estimation.particle_filters import initialize_particles
+from pytcl.dynamic_estimation.particle_filters import particle_covariance
+from pytcl.dynamic_estimation.particle_filters import particle_mean
+from pytcl.dynamic_estimation.particle_filters import resample_multinomial
+from pytcl.dynamic_estimation.particle_filters import resample_residual
+from pytcl.dynamic_estimation.particle_filters import resample_systematic
 
 # Smoothers
-from pytcl.dynamic_estimation.smoothers import (
-    FixedLagResult,
-    RTSResult,
-    SmoothedState,
-    fixed_interval_smoother,
-    fixed_lag_smoother,
-    rts_smoother,
-    rts_smoother_single_step,
-    two_filter_smoother,
-)
+from pytcl.dynamic_estimation.smoothers import FixedLagResult
+from pytcl.dynamic_estimation.smoothers import RTSResult
+from pytcl.dynamic_estimation.smoothers import SmoothedState
+from pytcl.dynamic_estimation.smoothers import fixed_interval_smoother
+from pytcl.dynamic_estimation.smoothers import fixed_lag_smoother
+from pytcl.dynamic_estimation.smoothers import rts_smoother
+from pytcl.dynamic_estimation.smoothers import rts_smoother_single_step
+from pytcl.dynamic_estimation.smoothers import two_filter_smoother
 
 # Re-export commonly used functions at the top level