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

pytcl/navigation/ins_gnss.py

@@ -17,20 +17,25 @@ References
        Kalman Filtering", 4th ed., Wiley, 2012.
 """
 
-from typing import List, NamedTuple, Optional, Tuple
+from typing import List
+from typing import NamedTuple
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
-
-from pytcl.dynamic_estimation.kalman import kf_predict, kf_update
-from pytcl.navigation.geodesy import WGS84, Ellipsoid, geodetic_to_ecef
-from pytcl.navigation.ins import (
-    IMUData,
-    INSState,
-    ins_error_state_matrix,
-    ins_process_noise_matrix,
-    mechanize_ins_ned,
-)
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
+
+from pytcl.dynamic_estimation.kalman import kf_predict
+from pytcl.dynamic_estimation.kalman import kf_update
+from pytcl.navigation.geodesy import WGS84
+from pytcl.navigation.geodesy import Ellipsoid
+from pytcl.navigation.geodesy import geodetic_to_ecef
+from pytcl.navigation.ins import IMUData
+from pytcl.navigation.ins import INSState
+from pytcl.navigation.ins import ins_error_state_matrix
+from pytcl.navigation.ins import ins_process_noise_matrix
+from pytcl.navigation.ins import mechanize_ins_ned
 
 # =============================================================================
 # Constants
@@ -512,9 +517,7 @@ def loose_coupled_predict(
     dt = imu.dt
 
     # Propagate INS mechanization
-    ins_new = mechanize_ins_ned(
-        state.ins_state, imu, accel_prev=accel_prev, gyro_prev=gyro_prev
-    )
+    ins_new = mechanize_ins_ned(state.ins_state, imu, accel_prev=accel_prev, gyro_prev=gyro_prev)
 
     # Get error state transition matrix (continuous-time)
     F_cont = ins_error_state_matrix(state.ins_state)
@@ -576,9 +579,7 @@ def loose_coupled_update_position(
     if gnss.position_cov is not None:
         R = gnss.position_cov
     else:
-        R = np.diag(
-            [10.0**2, 10.0**2, 15.0**2]
-        )  # Default: 10m horizontal, 15m vertical
+        R = np.diag([10.0**2, 10.0**2, 15.0**2])  # Default: 10m horizontal, 15m vertical
 
     # Innovation: measured position - INS predicted position
     z = gnss.position - state.ins_state.position
@@ -695,16 +696,8 @@ def loose_coupled_update(
         # Full position + velocity update
         H = position_velocity_measurement_matrix()
 
-        R_pos = (
-            gnss.position_cov
-            if gnss.position_cov is not None
-            else np.diag([10.0**2] * 3)
-        )
-        R_vel = (
-            gnss.velocity_cov
-            if gnss.velocity_cov is not None
-            else np.diag([0.1**2] * 3)
-        )
+        R_pos = gnss.position_cov if gnss.position_cov is not None else np.diag([10.0**2] * 3)
+        R_vel = gnss.velocity_cov if gnss.velocity_cov is not None else np.diag([0.1**2] * 3)
         R = np.block([[R_pos, np.zeros((3, 3))], [np.zeros((3, 3)), R_vel]])
 
         z = np.concatenate(
@@ -846,9 +839,7 @@ def tight_coupled_measurement_matrix(
         los, _ = compute_line_of_sight(user_ecef, sat.position)
 
         # LOS components in ECEF
-        los_x, los_y, los_z = (
-            -los
-        )  # Negative because increase in user pos decreases range
+        los_x, los_y, los_z = -los  # Negative because increase in user pos decreases range
 
         # Transform LOS to geodetic derivatives
         # d(range)/d(lat), d(range)/d(lon), d(range)/d(alt)
@@ -858,9 +849,7 @@ def tight_coupled_measurement_matrix(
             + los_z * (cos_lat * N * (1 - ellipsoid.e2))
         )
         H[i, 1] = los_x * (-cos_lat * sin_lon * N) + los_y * (cos_lat * cos_lon * N)
-        H[i, 2] = (
-            los_x * cos_lat * cos_lon + los_y * cos_lat * sin_lon + los_z * sin_lat
-        )
+        H[i, 2] = los_x * cos_lat * cos_lon + los_y * cos_lat * sin_lon + los_z * sin_lat
 
         # Clock bias (state 15)
         H[i, 15] = 1.0
@@ -991,9 +980,7 @@ def _apply_error_correction(
 
     # Apply small angle rotation to quaternion
     q = ins_state.quaternion
-    delta_q = np.array(
-        [1.0, 0.5 * phi[0], 0.5 * phi[1], 0.5 * phi[2]], dtype=np.float64
-    )
+    delta_q = np.array([1.0, 0.5 * phi[0], 0.5 * phi[1], 0.5 * phi[2]], dtype=np.float64)
     delta_q = delta_q / np.linalg.norm(delta_q)
 
     # Quaternion multiplication (body frame correction)

pytcl/navigation/rhumb.py

@@ -9,12 +9,14 @@ constant-bearing paths on a sphere and ellipsoid, including:
 - Spherical and ellipsoidal formulations
 """
 
-from typing import NamedTuple, Tuple
+from typing import NamedTuple
+from typing import Tuple
 
 import numpy as np
 from numpy.typing import NDArray
 
-from pytcl.navigation.geodesy import WGS84, Ellipsoid
+from pytcl.navigation.geodesy import WGS84
+from pytcl.navigation.geodesy import Ellipsoid
 
 
 class RhumbResult(NamedTuple):
@@ -100,9 +102,7 @@ def _isometric_latitude(lat: float, e2: float = 0.0) -> float:
         )
 
 
-def _inverse_isometric_latitude(
-    psi: float, e2: float = 0.0, max_iter: int = 20
-) -> float:
+def _inverse_isometric_latitude(psi: float, e2: float = 0.0, max_iter: int = 20) -> float:
     """
     Compute geodetic latitude from isometric latitude.
 
@@ -131,10 +131,7 @@ def _inverse_isometric_latitude(
         for _ in range(max_iter):
             sin_lat = np.sin(lat)
             lat_new = (
-                2
-                * np.arctan(
-                    ((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2) * np.exp(psi)
-                )
+                2 * np.arctan(((1 + e * sin_lat) / (1 - e * sin_lat)) ** (e / 2) * np.exp(psi))
                 - np.pi / 2
             )
             if abs(lat_new - lat) < 1e-12:
@@ -427,9 +424,7 @@ def indirect_rhumb(
     if abs(dlon) > np.pi:
         dlon = dlon - np.sign(dlon) * 2 * np.pi
 
-    dpsi = _isometric_latitude(lat2, ellipsoid.e2) - _isometric_latitude(
-        lat1, ellipsoid.e2
-    )
+    dpsi = _isometric_latitude(lat2, ellipsoid.e2) - _isometric_latitude(lat1, ellipsoid.e2)
     bearing = np.arctan2(dlon, dpsi) % (2 * np.pi)
 
     return RhumbResult(distance, bearing)

pytcl/performance_evaluation/__init__.py

@@ -27,33 +27,29 @@ RMSE: 0.100
 """
 
 # Estimation metrics
-from pytcl.performance_evaluation.estimation_metrics import (
-    ConsistencyResult,
-    average_nees,
-    consistency_test,
-    credibility_interval,
-    estimation_error_bounds,
-    monte_carlo_rmse,
-    nees,
-    nees_sequence,
-    nis,
-    nis_sequence,
-    position_rmse,
-    rmse,
-    velocity_rmse,
-)
+from pytcl.performance_evaluation.estimation_metrics import ConsistencyResult
+from pytcl.performance_evaluation.estimation_metrics import average_nees
+from pytcl.performance_evaluation.estimation_metrics import consistency_test
+from pytcl.performance_evaluation.estimation_metrics import credibility_interval
+from pytcl.performance_evaluation.estimation_metrics import estimation_error_bounds
+from pytcl.performance_evaluation.estimation_metrics import monte_carlo_rmse
+from pytcl.performance_evaluation.estimation_metrics import nees
+from pytcl.performance_evaluation.estimation_metrics import nees_sequence
+from pytcl.performance_evaluation.estimation_metrics import nis
+from pytcl.performance_evaluation.estimation_metrics import nis_sequence
+from pytcl.performance_evaluation.estimation_metrics import position_rmse
+from pytcl.performance_evaluation.estimation_metrics import rmse
+from pytcl.performance_evaluation.estimation_metrics import velocity_rmse
 
 # Track metrics
-from pytcl.performance_evaluation.track_metrics import (
-    MOTMetrics,
-    OSPAResult,
-    identity_switches,
-    mot_metrics,
-    ospa,
-    ospa_over_time,
-    track_fragmentation,
-    track_purity,
-)
+from pytcl.performance_evaluation.track_metrics import MOTMetrics
+from pytcl.performance_evaluation.track_metrics import OSPAResult
+from pytcl.performance_evaluation.track_metrics import identity_switches
+from pytcl.performance_evaluation.track_metrics import mot_metrics
+from pytcl.performance_evaluation.track_metrics import ospa
+from pytcl.performance_evaluation.track_metrics import ospa_over_time
+from pytcl.performance_evaluation.track_metrics import track_fragmentation
+from pytcl.performance_evaluation.track_metrics import track_purity
 
 __all__ = [
     # Track metrics

pytcl/performance_evaluation/estimation_metrics.py

@@ -10,7 +10,9 @@ References
        Applications to Tracking and Navigation," Wiley, 2001.
 """
 
-from typing import List, NamedTuple, Optional
+from typing import List
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
 from numpy.typing import NDArray

pytcl/performance_evaluation/track_metrics.py

@@ -14,7 +14,9 @@ References
        2008.
 """
 
-from typing import List, NamedTuple, Optional
+from typing import List
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
 from numpy.typing import NDArray
@@ -158,9 +160,7 @@ def ospa(
     loc_component = (localization_sum / n) ** (1.0 / p) if localization_sum > 0 else 0.0
     card_component = (cardinality_penalty / n) ** (1.0 / p) if n > m else 0.0
 
-    return OSPAResult(
-        ospa=ospa_val, localization=loc_component, cardinality=card_component
-    )
+    return OSPAResult(ospa=ospa_val, localization=loc_component, cardinality=card_component)
 
 
 def ospa_over_time(

pytcl/plotting/__init__.py

@@ -32,50 +32,42 @@ Plotly is required for all plotting functions. Install with:
 """
 
 # Coordinate system visualization
-from pytcl.plotting.coordinates import (
-    plot_coordinate_axes_3d,
-    plot_coordinate_transform,
-    plot_euler_angles,
-    plot_points_spherical,
-    plot_quaternion_interpolation,
-    plot_rotation_comparison,
-    plot_spherical_grid,
-)
+from pytcl.plotting.coordinates import plot_coordinate_axes_3d
+from pytcl.plotting.coordinates import plot_coordinate_transform
+from pytcl.plotting.coordinates import plot_euler_angles
+from pytcl.plotting.coordinates import plot_points_spherical
+from pytcl.plotting.coordinates import plot_quaternion_interpolation
+from pytcl.plotting.coordinates import plot_rotation_comparison
+from pytcl.plotting.coordinates import plot_spherical_grid
 
 # Covariance ellipse utilities
-from pytcl.plotting.ellipses import (
-    confidence_region_radius,
-    covariance_ellipse_points,
-    covariance_ellipsoid_points,
-    ellipse_parameters,
-    plot_covariance_ellipse,
-    plot_covariance_ellipses,
-    plot_covariance_ellipsoid,
-)
+from pytcl.plotting.ellipses import confidence_region_radius
+from pytcl.plotting.ellipses import covariance_ellipse_points
+from pytcl.plotting.ellipses import covariance_ellipsoid_points
+from pytcl.plotting.ellipses import ellipse_parameters
+from pytcl.plotting.ellipses import plot_covariance_ellipse
+from pytcl.plotting.ellipses import plot_covariance_ellipses
+from pytcl.plotting.ellipses import plot_covariance_ellipsoid
 
 # Performance metric visualization
-from pytcl.plotting.metrics import (
-    plot_cardinality_over_time,
-    plot_consistency_summary,
-    plot_error_histogram,
-    plot_monte_carlo_rmse,
-    plot_nees_sequence,
-    plot_nis_sequence,
-    plot_ospa_over_time,
-    plot_rmse_over_time,
-)
+from pytcl.plotting.metrics import plot_cardinality_over_time
+from pytcl.plotting.metrics import plot_consistency_summary
+from pytcl.plotting.metrics import plot_error_histogram
+from pytcl.plotting.metrics import plot_monte_carlo_rmse
+from pytcl.plotting.metrics import plot_nees_sequence
+from pytcl.plotting.metrics import plot_nis_sequence
+from pytcl.plotting.metrics import plot_ospa_over_time
+from pytcl.plotting.metrics import plot_rmse_over_time
 
 # Track and trajectory plotting
-from pytcl.plotting.tracks import (
-    create_animated_tracking,
-    plot_estimation_comparison,
-    plot_measurements_2d,
-    plot_multi_target_tracks,
-    plot_state_time_series,
-    plot_tracking_result,
-    plot_trajectory_2d,
-    plot_trajectory_3d,
-)
+from pytcl.plotting.tracks import create_animated_tracking
+from pytcl.plotting.tracks import plot_estimation_comparison
+from pytcl.plotting.tracks import plot_measurements_2d
+from pytcl.plotting.tracks import plot_multi_target_tracks
+from pytcl.plotting.tracks import plot_state_time_series
+from pytcl.plotting.tracks import plot_tracking_result
+from pytcl.plotting.tracks import plot_trajectory_2d
+from pytcl.plotting.tracks import plot_trajectory_3d
 
 __all__ = [
     # Ellipses

pytcl/plotting/coordinates.py

@@ -5,7 +5,9 @@ This module provides functions for visualizing coordinate systems,
 rotations, and transformations in 2D and 3D.
 """
 
-from typing import List, Optional, Tuple
+from typing import List
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike
@@ -181,19 +183,13 @@ def plot_euler_angles(
 
     # Create rotation matrices for each axis
     def rotx(a):
-        return np.array(
-            [[1, 0, 0], [0, np.cos(a), -np.sin(a)], [0, np.sin(a), np.cos(a)]]
-        )
+        return np.array([[1, 0, 0], [0, np.cos(a), -np.sin(a)], [0, np.sin(a), np.cos(a)]])
 
     def roty(a):
-        return np.array(
-            [[np.cos(a), 0, np.sin(a)], [0, 1, 0], [-np.sin(a), 0, np.cos(a)]]
-        )
+        return np.array([[np.cos(a), 0, np.sin(a)], [0, 1, 0], [-np.sin(a), 0, np.cos(a)]])
 
     def rotz(a):
-        return np.array(
-            [[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]]
-        )
+        return np.array([[np.cos(a), -np.sin(a), 0], [np.sin(a), np.cos(a), 0], [0, 0, 1]])
 
     rot_funcs = {"X": rotx, "Y": roty, "Z": rotz}
 
@@ -247,11 +243,7 @@ def plot_euler_angles(
     for i in range(4):
         scene_name = f"scene{i + 1}" if i > 0 else "scene"
         fig.update_layout(
-            **{
-                scene_name: dict(
-                    aspectmode="cube", camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
-                )
-            }
+            **{scene_name: dict(aspectmode="cube", camera=dict(eye=dict(x=1.5, y=1.5, z=1.5)))}
         )
 
     return fig
@@ -378,9 +370,7 @@ def plot_quaternion_interpolation(
                         method="animate",
                         args=[
                             [None],
-                            dict(
-                                frame=dict(duration=0, redraw=False), mode="immediate"
-                            ),
+                            dict(frame=dict(duration=0, redraw=False), mode="immediate"),
                         ],
                     ),
                 ],

pytcl/plotting/ellipses.py

@@ -5,10 +5,13 @@ This module provides functions for visualizing uncertainty as ellipses
 in 2D and 3D spaces, commonly used in tracking and estimation applications.
 """
 
-from typing import List, Optional, Tuple
+from typing import List
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 try:
     import plotly.graph_objects as go

pytcl/plotting/metrics.py

@@ -5,7 +5,8 @@ This module provides functions for visualizing tracking and estimation
 performance metrics such as RMSE, NEES, NIS, and OSPA.
 """
 
-from typing import List, Optional
+from typing import List
+from typing import Optional
 
 import numpy as np
 from numpy.typing import ArrayLike
@@ -148,9 +149,7 @@ def plot_nees_sequence(
     fig.add_trace(
         go.Scatter(
             x=np.concatenate([time, time[::-1]]),
-            y=np.concatenate(
-                [np.full(n_steps, upper_bound), np.full(n_steps, lower_bound)]
-            ),
+            y=np.concatenate([np.full(n_steps, upper_bound), np.full(n_steps, lower_bound)]),
             fill="toself",
             fillcolor="rgba(0, 255, 0, 0.1)",
             line=dict(color="rgba(0,0,0,0)"),
@@ -534,9 +533,7 @@ def plot_consistency_summary(
     fig.add_trace(
         go.Scatter(
             x=np.concatenate([time, time[::-1]]),
-            y=np.concatenate(
-                [np.full(n_steps, nees_upper), np.full(n_steps, nees_lower)]
-            ),
+            y=np.concatenate([np.full(n_steps, nees_upper), np.full(n_steps, nees_lower)]),
             fill="toself",
             fillcolor="rgba(0, 255, 0, 0.1)",
             line=dict(color="rgba(0,0,0,0)"),
@@ -580,9 +577,7 @@ def plot_consistency_summary(
         fig.add_trace(
             go.Scatter(
                 x=np.concatenate([time, time[::-1]]),
-                y=np.concatenate(
-                    [np.full(n_steps, nis_upper), np.full(n_steps, nis_lower)]
-                ),
+                y=np.concatenate([np.full(n_steps, nis_upper), np.full(n_steps, nis_lower)]),
                 fill="toself",
                 fillcolor="rgba(0, 255, 0, 0.1)",
                 line=dict(color="rgba(0,0,0,0)"),

pytcl/plotting/tracks.py

@@ -5,7 +5,10 @@ This module provides functions for visualizing trajectories, tracks,
 measurements, and estimation results in 2D and 3D.
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
 
 import numpy as np
 from numpy.typing import ArrayLike
@@ -369,11 +372,7 @@ def plot_multi_target_tracks(
 
     for idx, (track_id, states) in enumerate(tracks.items()):
         states = np.asarray(states)
-        color = (
-            colors.get(track_id)
-            if colors
-            else default_colors[idx % len(default_colors)]
-        )
+        color = colors.get(track_id) if colors else default_colors[idx % len(default_colors)]
 
         fig.add_trace(
             go.Scatter(
@@ -536,9 +535,7 @@ def plot_estimation_comparison(
 
         # Error bounds
         if covariances is not None:
-            sigma = n_std * np.array(
-                [np.sqrt(P[state_idx, state_idx]) for P in covariances]
-            )
+            sigma = n_std * np.array([np.sqrt(P[state_idx, state_idx]) for P in covariances])
             upper = estimates[:, state_idx] + sigma
             lower = estimates[:, state_idx] - sigma
 
@@ -740,9 +737,7 @@ def create_animated_tracking(
                         method="animate",
                         args=[
                             [None],
-                            dict(
-                                frame=dict(duration=0, redraw=False), mode="immediate"
-                            ),
+                            dict(frame=dict(duration=0, redraw=False), mode="immediate"),
                         ],
                     ),
                 ],

pytcl/static_estimation/__init__.py

@@ -5,50 +5,46 @@ This module provides methods for static (batch) estimation including
 least squares variants and robust estimation techniques.
 """
 
-from pytcl.static_estimation.least_squares import (
-    LSResult,
-    TLSResult,
-    WLSResult,
-    generalized_least_squares,
-    ordinary_least_squares,
-    recursive_least_squares,
-    ridge_regression,
-    total_least_squares,
-    weighted_least_squares,
-)
+from pytcl.static_estimation.least_squares import LSResult
+from pytcl.static_estimation.least_squares import TLSResult
+from pytcl.static_estimation.least_squares import WLSResult
+from pytcl.static_estimation.least_squares import generalized_least_squares
+from pytcl.static_estimation.least_squares import ordinary_least_squares
+from pytcl.static_estimation.least_squares import recursive_least_squares
+from pytcl.static_estimation.least_squares import ridge_regression
+from pytcl.static_estimation.least_squares import total_least_squares
+from pytcl.static_estimation.least_squares import weighted_least_squares
+from pytcl.static_estimation.maximum_likelihood import CRBResult
+from pytcl.static_estimation.maximum_likelihood import MLResult
+from pytcl.static_estimation.maximum_likelihood import aic
+from pytcl.static_estimation.maximum_likelihood import aicc
+from pytcl.static_estimation.maximum_likelihood import bic
+from pytcl.static_estimation.maximum_likelihood import cramer_rao_bound
+from pytcl.static_estimation.maximum_likelihood import cramer_rao_bound_biased
+from pytcl.static_estimation.maximum_likelihood import efficiency
 from pytcl.static_estimation.maximum_likelihood import (
-    CRBResult,
-    MLResult,
-    aic,
-    aicc,
-    bic,
-    cramer_rao_bound,
-    cramer_rao_bound_biased,
-    efficiency,
     fisher_information_exponential_family,
-    fisher_information_gaussian,
-    fisher_information_numerical,
-    mle_gaussian,
-    mle_newton_raphson,
-    mle_scoring,
-    observed_fisher_information,
-)
-from pytcl.static_estimation.robust import (
-    RANSACResult,
-    RobustResult,
-    cauchy_weight,
-    huber_regression,
-    huber_rho,
-    huber_weight,
-    irls,
-    mad,
-    ransac,
-    ransac_n_trials,
-    tau_scale,
-    tukey_regression,
-    tukey_rho,
-    tukey_weight,
 )
+from pytcl.static_estimation.maximum_likelihood import fisher_information_gaussian
+from pytcl.static_estimation.maximum_likelihood import fisher_information_numerical
+from pytcl.static_estimation.maximum_likelihood import mle_gaussian
+from pytcl.static_estimation.maximum_likelihood import mle_newton_raphson
+from pytcl.static_estimation.maximum_likelihood import mle_scoring
+from pytcl.static_estimation.maximum_likelihood import observed_fisher_information
+from pytcl.static_estimation.robust import RANSACResult
+from pytcl.static_estimation.robust import RobustResult
+from pytcl.static_estimation.robust import cauchy_weight
+from pytcl.static_estimation.robust import huber_regression
+from pytcl.static_estimation.robust import huber_rho
+from pytcl.static_estimation.robust import huber_weight
+from pytcl.static_estimation.robust import irls
+from pytcl.static_estimation.robust import mad
+from pytcl.static_estimation.robust import ransac
+from pytcl.static_estimation.robust import ransac_n_trials
+from pytcl.static_estimation.robust import tau_scale
+from pytcl.static_estimation.robust import tukey_regression
+from pytcl.static_estimation.robust import tukey_rho
+from pytcl.static_estimation.robust import tukey_weight
 
 __all__ = [
     # Least squares results

pytcl/static_estimation/least_squares.py

@@ -12,10 +12,12 @@ References
        Johns Hopkins University Press, 2013.
 """
 
-from typing import NamedTuple, Optional
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 class LSResult(NamedTuple):
@@ -303,8 +305,7 @@ def total_least_squares(
     # The solution exists if V[n, n] != 0
     if abs(V[n, n]) < 1e-14:
         raise ValueError(
-            "TLS solution does not exist. The smallest singular value "
-            "has multiplicity > 1."
+            "TLS solution does not exist. The smallest singular value " "has multiplicity > 1."
         )
 
     # TLS solution: x = -V[0:n, n] / V[n, n]

pytcl/static_estimation/maximum_likelihood.py

@@ -12,10 +12,13 @@ References
        Wiley, 2001.
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Callable
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 class MLResult(NamedTuple):
@@ -654,9 +657,9 @@ def mle_gaussian(
         theta = np.array(theta)
 
         # Log-likelihood
-        log_lik = -n / 2 * np.log(2 * np.pi * var_mle) - np.sum(
-            (data - mean_mle) ** 2
-        ) / (2 * var_mle)
+        log_lik = -n / 2 * np.log(2 * np.pi * var_mle) - np.sum((data - mean_mle) ** 2) / (
+            2 * var_mle
+        )
 
         # Fisher information
         n_params = len(theta)

pytcl/static_estimation/robust.py

@@ -12,10 +12,13 @@ References
        Cartography," Communications of the ACM, 1981.
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Callable
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 class RobustResult(NamedTuple):