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

pytcl/dynamic_estimation/imm.py

@@ -12,15 +12,16 @@ The IMM algorithm consists of four steps:
 4. Output combination
 """
 
-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 ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
-from pytcl.dynamic_estimation.kalman.linear import (
-    kf_predict,
-    kf_update,
-)
+from pytcl.dynamic_estimation.kalman.linear import kf_predict
+from pytcl.dynamic_estimation.kalman.linear import kf_update
 
 
 class IMMState(NamedTuple):
@@ -472,12 +473,8 @@ def imm_predict_update(
     result : IMMUpdate
         Updated states, covariances, and mode probabilities.
     """
-    pred = imm_predict(
-        mode_states, mode_covs, mode_probs, transition_matrix, F_list, Q_list
-    )
-    return imm_update(
-        pred.mode_states, pred.mode_covs, pred.mode_probs, z, H_list, R_list
-    )
+    pred = imm_predict(mode_states, mode_covs, mode_probs, transition_matrix, F_list, Q_list)
+    return imm_update(pred.mode_states, pred.mode_covs, pred.mode_probs, z, H_list, R_list)
 
 
 class IMMEstimator:
@@ -679,9 +676,7 @@ class IMMEstimator:
             Update result.
         """
         if not self.H_list:
-            raise ValueError(
-                "Measurement model not set. Call set_measurement_model first."
-            )
+            raise ValueError("Measurement model not set. Call set_measurement_model first.")
 
         result = imm_update(
             self.mode_states,

pytcl/dynamic_estimation/information_filter.py

@@ -16,15 +16,17 @@ This module provides:
 - Square-Root Information Filter (SRIF) for improved numerical stability
 """
 
-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 numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
-from pytcl.dynamic_estimation.kalman.linear import (
-    information_filter_predict,
-    information_filter_update,
-)
+from pytcl.dynamic_estimation.kalman.linear import information_filter_predict
+from pytcl.dynamic_estimation.kalman.linear import information_filter_update
 
 
 class InformationState(NamedTuple):

pytcl/dynamic_estimation/kalman/__init__.py

@@ -11,54 +11,46 @@ This module provides:
 - U-D factorization filter (Bierman's method)
 """
 
-from pytcl.dynamic_estimation.kalman.extended import (
-    ekf_predict,
-    ekf_predict_auto,
-    ekf_update,
-    ekf_update_auto,
-    iterated_ekf_update,
-    numerical_jacobian,
-)
-from pytcl.dynamic_estimation.kalman.linear import (
-    KalmanPrediction,
-    KalmanState,
-    KalmanUpdate,
-    information_filter_predict,
-    information_filter_update,
-    kf_predict,
-    kf_predict_update,
-    kf_smooth,
-    kf_update,
-)
-from pytcl.dynamic_estimation.kalman.square_root import (
-    SRKalmanPrediction,
-    SRKalmanState,
-    SRKalmanUpdate,
-    UDState,
-    cholesky_update,
-    qr_update,
-    sr_ukf_predict,
-    sr_ukf_update,
-    srkf_predict,
-    srkf_predict_update,
-    srkf_update,
-    ud_factorize,
-    ud_predict,
-    ud_reconstruct,
-    ud_update,
-    ud_update_scalar,
-)
-from pytcl.dynamic_estimation.kalman.unscented import (
-    SigmaPoints,
-    ckf_predict,
-    ckf_spherical_cubature_points,
-    ckf_update,
-    sigma_points_julier,
-    sigma_points_merwe,
-    ukf_predict,
-    ukf_update,
-    unscented_transform,
-)
+from pytcl.dynamic_estimation.kalman.extended import ekf_predict
+from pytcl.dynamic_estimation.kalman.extended import ekf_predict_auto
+from pytcl.dynamic_estimation.kalman.extended import ekf_update
+from pytcl.dynamic_estimation.kalman.extended import ekf_update_auto
+from pytcl.dynamic_estimation.kalman.extended import iterated_ekf_update
+from pytcl.dynamic_estimation.kalman.extended import numerical_jacobian
+from pytcl.dynamic_estimation.kalman.linear import KalmanPrediction
+from pytcl.dynamic_estimation.kalman.linear import KalmanState
+from pytcl.dynamic_estimation.kalman.linear import KalmanUpdate
+from pytcl.dynamic_estimation.kalman.linear import information_filter_predict
+from pytcl.dynamic_estimation.kalman.linear import information_filter_update
+from pytcl.dynamic_estimation.kalman.linear import kf_predict
+from pytcl.dynamic_estimation.kalman.linear import kf_predict_update
+from pytcl.dynamic_estimation.kalman.linear import kf_smooth
+from pytcl.dynamic_estimation.kalman.linear import kf_update
+from pytcl.dynamic_estimation.kalman.square_root import SRKalmanPrediction
+from pytcl.dynamic_estimation.kalman.square_root import SRKalmanState
+from pytcl.dynamic_estimation.kalman.square_root import SRKalmanUpdate
+from pytcl.dynamic_estimation.kalman.square_root import UDState
+from pytcl.dynamic_estimation.kalman.square_root import cholesky_update
+from pytcl.dynamic_estimation.kalman.square_root import qr_update
+from pytcl.dynamic_estimation.kalman.square_root import sr_ukf_predict
+from pytcl.dynamic_estimation.kalman.square_root import sr_ukf_update
+from pytcl.dynamic_estimation.kalman.square_root import srkf_predict
+from pytcl.dynamic_estimation.kalman.square_root import srkf_predict_update
+from pytcl.dynamic_estimation.kalman.square_root import srkf_update
+from pytcl.dynamic_estimation.kalman.square_root import ud_factorize
+from pytcl.dynamic_estimation.kalman.square_root import ud_predict
+from pytcl.dynamic_estimation.kalman.square_root import ud_reconstruct
+from pytcl.dynamic_estimation.kalman.square_root import ud_update
+from pytcl.dynamic_estimation.kalman.square_root import ud_update_scalar
+from pytcl.dynamic_estimation.kalman.unscented import SigmaPoints
+from pytcl.dynamic_estimation.kalman.unscented import ckf_predict
+from pytcl.dynamic_estimation.kalman.unscented import ckf_spherical_cubature_points
+from pytcl.dynamic_estimation.kalman.unscented import ckf_update
+from pytcl.dynamic_estimation.kalman.unscented import sigma_points_julier
+from pytcl.dynamic_estimation.kalman.unscented import sigma_points_merwe
+from pytcl.dynamic_estimation.kalman.unscented import ukf_predict
+from pytcl.dynamic_estimation.kalman.unscented import ukf_update
+from pytcl.dynamic_estimation.kalman.unscented import unscented_transform
 
 __all__ = [
     # Linear KF

pytcl/dynamic_estimation/kalman/extended.py

@@ -8,12 +8,11 @@ around the current state estimate using Jacobians.
 from typing import Callable
 
 import numpy as np
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
-from pytcl.dynamic_estimation.kalman.linear import (
-    KalmanPrediction,
-    KalmanUpdate,
-)
+from pytcl.dynamic_estimation.kalman.linear import KalmanPrediction
+from pytcl.dynamic_estimation.kalman.linear import KalmanUpdate
 
 
 def ekf_predict(

pytcl/dynamic_estimation/kalman/linear.py

@@ -5,11 +5,15 @@ This module provides the standard linear Kalman filter for systems with
 linear dynamics and linear measurements with Gaussian noise.
 """
 
-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 ArrayLike, NDArray
-from scipy.linalg import cho_factor, cho_solve
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
+from scipy.linalg import cho_factor
+from scipy.linalg import cho_solve
 
 
 class KalmanState(NamedTuple):

pytcl/dynamic_estimation/kalman/square_root.py

@@ -12,11 +12,14 @@ Implementations include:
 - Square-root versions of UKF and CKF
 """
 
-from typing import Callable, NamedTuple, Optional
+from typing import Callable
+from typing import NamedTuple
+from typing import Optional
 
 import numpy as np
 import scipy.linalg
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 class SRKalmanState(NamedTuple):
@@ -705,9 +708,7 @@ def ud_update(
         D_upd = D.copy()
 
         for i in range(m):
-            x_upd, U_upd, D_upd = ud_update_scalar(
-                x_upd, U_upd, D_upd, z[i], H[i, :], R[i, i]
-            )
+            x_upd, U_upd, D_upd = ud_update_scalar(x_upd, U_upd, D_upd, z[i], H[i, :], R[i, i])
     else:
         # Decorrelate measurements
         S_R = np.linalg.cholesky(R)
@@ -720,9 +721,7 @@ def ud_update(
         D_upd = D.copy()
 
         for i in range(m):
-            x_upd, U_upd, D_upd = ud_update_scalar(
-                x_upd, U_upd, D_upd, z_dec[i], H_dec[i, :], 1.0
-            )
+            x_upd, U_upd, D_upd = ud_update_scalar(x_upd, U_upd, D_upd, z_dec[i], H_dec[i, :], 1.0)
 
     # Compute likelihood
     P = ud_reconstruct(U, D)

pytcl/dynamic_estimation/kalman/unscented.py

@@ -5,15 +5,17 @@ The UKF uses the unscented transform to propagate the mean and covariance
 through nonlinear functions without requiring Jacobian computation.
 """
 
-from typing import Callable, NamedTuple, Optional, Tuple
+from typing import Callable
+from typing import NamedTuple
+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
 
-from pytcl.dynamic_estimation.kalman.linear import (
-    KalmanPrediction,
-    KalmanUpdate,
-)
+from pytcl.dynamic_estimation.kalman.linear import KalmanPrediction
+from pytcl.dynamic_estimation.kalman.linear import KalmanUpdate
 
 
 class SigmaPoints(NamedTuple):

pytcl/dynamic_estimation/particle_filters/__init__.py

@@ -7,20 +7,18 @@ This module provides:
 - Particle statistics (mean, covariance, ESS)
 """
 
-from pytcl.dynamic_estimation.particle_filters.bootstrap 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.bootstrap import ParticleState
+from pytcl.dynamic_estimation.particle_filters.bootstrap import bootstrap_pf_predict
+from pytcl.dynamic_estimation.particle_filters.bootstrap import bootstrap_pf_step
+from pytcl.dynamic_estimation.particle_filters.bootstrap import bootstrap_pf_update
+from pytcl.dynamic_estimation.particle_filters.bootstrap import effective_sample_size
+from pytcl.dynamic_estimation.particle_filters.bootstrap import gaussian_likelihood
+from pytcl.dynamic_estimation.particle_filters.bootstrap import initialize_particles
+from pytcl.dynamic_estimation.particle_filters.bootstrap import particle_covariance
+from pytcl.dynamic_estimation.particle_filters.bootstrap import particle_mean
+from pytcl.dynamic_estimation.particle_filters.bootstrap import resample_multinomial
+from pytcl.dynamic_estimation.particle_filters.bootstrap import resample_residual
+from pytcl.dynamic_estimation.particle_filters.bootstrap import resample_systematic
 
 __all__ = [
     "ParticleState",

pytcl/dynamic_estimation/particle_filters/bootstrap.py

@@ -5,11 +5,15 @@ This module provides particle filtering algorithms for nonlinear/non-Gaussian
 state estimation.
 """
 
-from typing import Callable, NamedTuple, Optional, Tuple
+from typing import Callable
+from typing import NamedTuple
+from typing import Optional
+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
 
 
 class ParticleState(NamedTuple):
@@ -157,9 +161,7 @@ def resample_residual(
     residual = Nw - floor_Nw
 
     # Deterministic copies (JIT-compiled)
-    resampled, idx = _resample_residual_deterministic(
-        particles.astype(np.float64), floor_Nw
-    )
+    resampled, idx = _resample_residual_deterministic(particles.astype(np.float64), floor_Nw)
 
     # Multinomial resampling of residuals
     if idx < N:
@@ -271,9 +273,7 @@ def bootstrap_pf_update(
     N = len(particles)
 
     # Compute likelihoods
-    likelihoods = np.array(
-        [likelihood_func(z, particles[i]) for i in range(N)], dtype=np.float64
-    )
+    likelihoods = np.array([likelihood_func(z, particles[i]) for i in range(N)], dtype=np.float64)
 
     # Update weights
     weights_unnorm = weights * likelihoods

pytcl/dynamic_estimation/smoothers.py

@@ -12,16 +12,17 @@ The main algorithms are:
 - Two-filter smoother for parallel processing
 """
 
-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 ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
-from pytcl.dynamic_estimation.kalman.linear import (
-    kf_predict,
-    kf_smooth,
-    kf_update,
-)
+from pytcl.dynamic_estimation.kalman.linear import kf_predict
+from pytcl.dynamic_estimation.kalman.linear import kf_smooth
+from pytcl.dynamic_estimation.kalman.linear import kf_update
 
 
 class SmoothedState(NamedTuple):
@@ -650,9 +651,7 @@ def rts_smoother_single_step(
     result : SmoothedState
         Smoothed state and covariance at current time.
     """
-    x_s, P_s = kf_smooth(
-        x_filt, P_filt, x_pred_next, P_pred_next, x_smooth_next, P_smooth_next, F
-    )
+    x_s, P_s = kf_smooth(x_filt, P_filt, x_pred_next, P_pred_next, x_smooth_next, P_smooth_next, F)
     return SmoothedState(x=x_s, P=P_s)
 
 

pytcl/dynamic_models/__init__.py

@@ -14,53 +14,49 @@ and utilities for discretizing continuous-time models.
 """
 
 # Import submodules for easy access
-from pytcl.dynamic_models import continuous_time, discrete_time, process_noise
+from pytcl.dynamic_models import continuous_time
+from pytcl.dynamic_models import discrete_time
+from pytcl.dynamic_models import process_noise
 
 # Continuous-time dynamics
-from pytcl.dynamic_models.continuous_time import (
-    continuous_to_discrete,
-    diffusion_constant_acceleration,
-    diffusion_constant_velocity,
-    diffusion_singer,
-    discretize_lti,
-    drift_constant_acceleration,
-    drift_constant_velocity,
-    drift_coordinated_turn_2d,
-    drift_singer,
-    state_jacobian_ca,
-    state_jacobian_cv,
-    state_jacobian_singer,
-)
+from pytcl.dynamic_models.continuous_time import continuous_to_discrete
+from pytcl.dynamic_models.continuous_time import diffusion_constant_acceleration
+from pytcl.dynamic_models.continuous_time import diffusion_constant_velocity
+from pytcl.dynamic_models.continuous_time import diffusion_singer
+from pytcl.dynamic_models.continuous_time import discretize_lti
+from pytcl.dynamic_models.continuous_time import drift_constant_acceleration
+from pytcl.dynamic_models.continuous_time import drift_constant_velocity
+from pytcl.dynamic_models.continuous_time import drift_coordinated_turn_2d
+from pytcl.dynamic_models.continuous_time import drift_singer
+from pytcl.dynamic_models.continuous_time import state_jacobian_ca
+from pytcl.dynamic_models.continuous_time import state_jacobian_cv
+from pytcl.dynamic_models.continuous_time import state_jacobian_singer
 
 # Discrete-time state transition matrices
-from pytcl.dynamic_models.discrete_time import (
-    f_constant_acceleration,
-    f_constant_velocity,
-    f_coord_turn_2d,
-    f_coord_turn_3d,
-    f_coord_turn_polar,
-    f_discrete_white_noise_accel,
-    f_piecewise_white_noise_jerk,
-    f_poly_kal,
-    f_singer,
-    f_singer_2d,
-    f_singer_3d,
-)
+from pytcl.dynamic_models.discrete_time import f_constant_acceleration
+from pytcl.dynamic_models.discrete_time import f_constant_velocity
+from pytcl.dynamic_models.discrete_time import f_coord_turn_2d
+from pytcl.dynamic_models.discrete_time import f_coord_turn_3d
+from pytcl.dynamic_models.discrete_time import f_coord_turn_polar
+from pytcl.dynamic_models.discrete_time import f_discrete_white_noise_accel
+from pytcl.dynamic_models.discrete_time import f_piecewise_white_noise_jerk
+from pytcl.dynamic_models.discrete_time import f_poly_kal
+from pytcl.dynamic_models.discrete_time import f_singer
+from pytcl.dynamic_models.discrete_time import f_singer_2d
+from pytcl.dynamic_models.discrete_time import f_singer_3d
 
 # Process noise covariance matrices
-from pytcl.dynamic_models.process_noise import (
-    q_constant_acceleration,
-    q_constant_velocity,
-    q_continuous_white_noise,
-    q_coord_turn_2d,
-    q_coord_turn_3d,
-    q_coord_turn_polar,
-    q_discrete_white_noise,
-    q_poly_kal,
-    q_singer,
-    q_singer_2d,
-    q_singer_3d,
-)
+from pytcl.dynamic_models.process_noise import q_constant_acceleration
+from pytcl.dynamic_models.process_noise import q_constant_velocity
+from pytcl.dynamic_models.process_noise import q_continuous_white_noise
+from pytcl.dynamic_models.process_noise import q_coord_turn_2d
+from pytcl.dynamic_models.process_noise import q_coord_turn_3d
+from pytcl.dynamic_models.process_noise import q_coord_turn_polar
+from pytcl.dynamic_models.process_noise import q_discrete_white_noise
+from pytcl.dynamic_models.process_noise import q_poly_kal
+from pytcl.dynamic_models.process_noise import q_singer
+from pytcl.dynamic_models.process_noise import q_singer_2d
+from pytcl.dynamic_models.process_noise import q_singer_3d
 
 # Re-export commonly used functions at the top level
 

pytcl/dynamic_models/continuous_time/__init__.py

@@ -5,20 +5,20 @@ This module provides drift and diffusion functions for continuous-time
 stochastic differential equations, as well as utilities for discretization.
 """
 
+from pytcl.dynamic_models.continuous_time.dynamics import continuous_to_discrete
 from pytcl.dynamic_models.continuous_time.dynamics import (
-    continuous_to_discrete,
     diffusion_constant_acceleration,
-    diffusion_constant_velocity,
-    diffusion_singer,
-    discretize_lti,
-    drift_constant_acceleration,
-    drift_constant_velocity,
-    drift_coordinated_turn_2d,
-    drift_singer,
-    state_jacobian_ca,
-    state_jacobian_cv,
-    state_jacobian_singer,
 )
+from pytcl.dynamic_models.continuous_time.dynamics import diffusion_constant_velocity
+from pytcl.dynamic_models.continuous_time.dynamics import diffusion_singer
+from pytcl.dynamic_models.continuous_time.dynamics import discretize_lti
+from pytcl.dynamic_models.continuous_time.dynamics import drift_constant_acceleration
+from pytcl.dynamic_models.continuous_time.dynamics import drift_constant_velocity
+from pytcl.dynamic_models.continuous_time.dynamics import drift_coordinated_turn_2d
+from pytcl.dynamic_models.continuous_time.dynamics import drift_singer
+from pytcl.dynamic_models.continuous_time.dynamics import state_jacobian_ca
+from pytcl.dynamic_models.continuous_time.dynamics import state_jacobian_cv
+from pytcl.dynamic_models.continuous_time.dynamics import state_jacobian_singer
 
 __all__ = [
     # Drift functions

pytcl/dynamic_models/continuous_time/dynamics.py

@@ -9,11 +9,13 @@ stochastic differential equations of the form:
 where W is a Wiener process.
 """
 
-from typing import Optional, Tuple
+from typing import Optional
+from typing import Tuple
 
 import numpy as np
 import scipy.linalg
-from numpy.typing import ArrayLike, NDArray
+from numpy.typing import ArrayLike
+from numpy.typing import NDArray
 
 
 def drift_constant_velocity(

pytcl/dynamic_models/discrete_time/__init__.py

@@ -5,23 +5,17 @@ This module provides state transition matrices (F) for various motion models
 used in target tracking applications.
 """
 
-from pytcl.dynamic_models.discrete_time.coordinated_turn import (
-    f_coord_turn_2d,
-    f_coord_turn_3d,
-    f_coord_turn_polar,
-)
-from pytcl.dynamic_models.discrete_time.polynomial import (
-    f_constant_acceleration,
-    f_constant_velocity,
-    f_discrete_white_noise_accel,
-    f_piecewise_white_noise_jerk,
-    f_poly_kal,
-)
-from pytcl.dynamic_models.discrete_time.singer import (
-    f_singer,
-    f_singer_2d,
-    f_singer_3d,
-)
+from pytcl.dynamic_models.discrete_time.coordinated_turn import f_coord_turn_2d
+from pytcl.dynamic_models.discrete_time.coordinated_turn import f_coord_turn_3d
+from pytcl.dynamic_models.discrete_time.coordinated_turn import f_coord_turn_polar
+from pytcl.dynamic_models.discrete_time.polynomial import f_constant_acceleration
+from pytcl.dynamic_models.discrete_time.polynomial import f_constant_velocity
+from pytcl.dynamic_models.discrete_time.polynomial import f_discrete_white_noise_accel
+from pytcl.dynamic_models.discrete_time.polynomial import f_piecewise_white_noise_jerk
+from pytcl.dynamic_models.discrete_time.polynomial import f_poly_kal
+from pytcl.dynamic_models.discrete_time.singer import f_singer
+from pytcl.dynamic_models.discrete_time.singer import f_singer_2d
+from pytcl.dynamic_models.discrete_time.singer import f_singer_3d
 
 __all__ = [
     # Polynomial models

pytcl/dynamic_models/process_noise/__init__.py

@@ -5,23 +5,17 @@ This module provides process noise covariance matrices (Q) for various
 motion models used in target tracking applications.
 """
 
-from pytcl.dynamic_models.process_noise.coordinated_turn import (
-    q_coord_turn_2d,
-    q_coord_turn_3d,
-    q_coord_turn_polar,
-)
-from pytcl.dynamic_models.process_noise.polynomial import (
-    q_constant_acceleration,
-    q_constant_velocity,
-    q_continuous_white_noise,
-    q_discrete_white_noise,
-    q_poly_kal,
-)
-from pytcl.dynamic_models.process_noise.singer import (
-    q_singer,
-    q_singer_2d,
-    q_singer_3d,
-)
+from pytcl.dynamic_models.process_noise.coordinated_turn import q_coord_turn_2d
+from pytcl.dynamic_models.process_noise.coordinated_turn import q_coord_turn_3d
+from pytcl.dynamic_models.process_noise.coordinated_turn import q_coord_turn_polar
+from pytcl.dynamic_models.process_noise.polynomial import q_constant_acceleration
+from pytcl.dynamic_models.process_noise.polynomial import q_constant_velocity
+from pytcl.dynamic_models.process_noise.polynomial import q_continuous_white_noise
+from pytcl.dynamic_models.process_noise.polynomial import q_discrete_white_noise
+from pytcl.dynamic_models.process_noise.polynomial import q_poly_kal
+from pytcl.dynamic_models.process_noise.singer import q_singer
+from pytcl.dynamic_models.process_noise.singer import q_singer_2d
+from pytcl.dynamic_models.process_noise.singer import q_singer_3d
 
 __all__ = [
     # Polynomial models

pytcl/dynamic_models/process_noise/polynomial.py

@@ -71,9 +71,7 @@ def q_poly_kal(
 
             # Q[i,j] = q * T^(pi+pj+1) / ((pi+pj+1) * pi! * pj!)
             power = pi + pj + 1
-            Q_1d[i, j] = (
-                q * T**power / (power * math.factorial(pi) * math.factorial(pj))
-            )
+            Q_1d[i, j] = q * T**power / (power * math.factorial(pi) * math.factorial(pj))
 
     if num_dims == 1:
         return Q_1d
@@ -276,9 +274,7 @@ def q_continuous_white_noise(
     """
     # This is the same as q_discrete_white_noise but with spectral density
     # instead of variance (multiply by T for conversion in simple cases)
-    return q_discrete_white_noise(
-        dim=dim, T=T, var=spectral_density, block_size=block_size
-    )
+    return q_discrete_white_noise(dim=dim, T=T, var=spectral_density, block_size=block_size)
 
 
 __all__ = [