nrl-tracker 1.9.1__py3-none-any.whl → 1.9.2__py3-none-any.whl

pytcl/mathematical_functions/special_functions/gamma_functions.py

@@ -95,6 +95,11 @@ def gammainc(a: ArrayLike, x: ArrayLike) -> NDArray[np.floating]:
     -----
     This is the CDF of the gamma distribution.
 
+    Examples
+    --------
+    >>> gammainc(1, 1)  # 1 - exp(-1)
+    0.632...
+
     See Also
     --------
     scipy.special.gammainc : Regularized lower incomplete gamma function.
@@ -121,6 +126,11 @@ def gammaincc(a: ArrayLike, x: ArrayLike) -> NDArray[np.floating]:
     Q : ndarray
         Values of the regularized upper incomplete gamma function.
 
+    Examples
+    --------
+    >>> gammaincc(1, 1)  # exp(-1)
+    0.367...
+
     See Also
     --------
     scipy.special.gammaincc : Regularized upper incomplete gamma function.
@@ -146,6 +156,11 @@ def gammaincinv(a: ArrayLike, y: ArrayLike) -> NDArray[np.floating]:
     x : ndarray
         Values where P(a, x) = y.
 
+    Examples
+    --------
+    >>> gammaincinv(1, 0.5)  # Median of exponential distribution
+    0.693...
+
     See Also
     --------
     scipy.special.gammaincinv : Inverse of lower incomplete gamma.
@@ -169,6 +184,11 @@ def digamma(x: ArrayLike) -> NDArray[np.floating]:
     ψ : ndarray
         Values of the digamma function.
 
+    Examples
+    --------
+    >>> digamma(1)  # -γ (negative Euler-Mascheroni constant)
+    -0.577...
+
     See Also
     --------
     scipy.special.digamma : Digamma function.
@@ -195,6 +215,13 @@ def polygamma(n: int, x: ArrayLike) -> NDArray[np.floating]:
     ψn : ndarray
         Values of the n-th polygamma function.
 
+    Examples
+    --------
+    >>> polygamma(0, 1)  # Digamma at 1 = -γ
+    -0.577...
+    >>> polygamma(1, 1)  # Trigamma at 1 = π²/6
+    1.644...
+
     See Also
     --------
     scipy.special.polygamma : Polygamma function.
@@ -252,6 +279,12 @@ def betaln(a: ArrayLike, b: ArrayLike) -> NDArray[np.floating]:
     lnB : ndarray
         Values of ln(B(a, b)).
 
+    Examples
+    --------
+    >>> import numpy as np
+    >>> betaln(100, 100)  # More stable than log(beta(100, 100))
+    -137.74...
+
     See Also
     --------
     scipy.special.betaln : Log of beta function.
@@ -284,6 +317,11 @@ def betainc(a: ArrayLike, b: ArrayLike, x: ArrayLike) -> NDArray[np.floating]:
     -----
     This is the CDF of the beta distribution.
 
+    Examples
+    --------
+    >>> betainc(1, 1, 0.5)  # Uniform distribution CDF at 0.5
+    0.5
+
     See Also
     --------
     scipy.special.betainc : Regularized incomplete beta function.
@@ -311,6 +349,11 @@ def betaincinv(a: ArrayLike, b: ArrayLike, y: ArrayLike) -> NDArray[np.floating]
     x : ndarray
         Values where I_x(a, b) = y.
 
+    Examples
+    --------
+    >>> betaincinv(1, 1, 0.5)  # Median of uniform distribution
+    0.5
+
     See Also
     --------
     scipy.special.betaincinv : Inverse of incomplete beta function.

pytcl/mathematical_functions/special_functions/lambert_w.py

@@ -170,6 +170,11 @@ def wright_omega(z: ArrayLike) -> NDArray[np.complexfloating]:
 
     It is entire (analytic everywhere) unlike the Lambert W function.
 
+    Examples
+    --------
+    >>> wright_omega(0)  # Omega constant
+    (0.5671...+0j)
+
     References
     ----------
     .. [1] Wright, E.M. (1959). "Solution of the equation z*exp(z) = a".

pytcl/mathematical_functions/special_functions/marcum_q.py

@@ -112,6 +112,11 @@ def marcum_q1(
     Q : ndarray
         Values of Q_1(a, b).
 
+    Examples
+    --------
+    >>> marcum_q1(2, 2)
+    0.735...
+
     See Also
     --------
     marcum_q : Generalized Marcum Q function.
@@ -274,6 +279,11 @@ def nuttall_q(
     -----
     This is the probability P(X <= b^2) for X ~ chi^2(2, a^2).
 
+    Examples
+    --------
+    >>> nuttall_q(2, 2)  # 1 - Q_1(2, 2)
+    0.264...
+
     See Also
     --------
     marcum_q : Marcum Q function.
@@ -322,6 +332,12 @@ def swerling_detection_probability(
     For Swerling 1:
         P_d = exp(-threshold / (2 + 2*n*SNR)) * (1 + n*SNR/...)
 
+    Examples
+    --------
+    >>> pd = swerling_detection_probability(10, 1e-6, n_pulses=10, swerling_case=0)
+    >>> pd > 0.9  # High probability of detection with 10 dB SNR
+    True
+
     References
     ----------
     .. [1] Swerling, P. (1960). "Probability of Detection for Fluctuating

pytcl/navigation/geodesy.py

@@ -280,8 +280,17 @@ def geodetic_to_ecef(
     Examples
     --------
     >>> import numpy as np
+    >>> # Philadelphia (40°N, 75°W) at 100m altitude
     >>> lat, lon, alt = np.radians(40.0), np.radians(-75.0), 100.0
     >>> x, y, z = geodetic_to_ecef(lat, lon, alt)
+    >>> x / 1e6  # ~1.2 million meters
+    1.24...
+    >>> # Equator at prime meridian
+    >>> x, y, z = geodetic_to_ecef(0.0, 0.0, 0.0)
+    >>> x  # Semi-major axis (equatorial radius)
+    6378137.0
+    >>> y, z
+    (0.0, 0.0)
     """
     lat = np.asarray(lat, dtype=np.float64)
     lon = np.asarray(lon, dtype=np.float64)
@@ -327,6 +336,19 @@ def ecef_to_geodetic(
     alt : ndarray
         Altitude above ellipsoid in meters.
 
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Point on equator at prime meridian
+    >>> lat, lon, alt = ecef_to_geodetic(6378137.0, 0.0, 0.0)
+    >>> np.degrees(lat), np.degrees(lon), alt
+    (0.0, 0.0, 0.0)
+    >>> # Round-trip conversion
+    >>> x, y, z = geodetic_to_ecef(np.radians(45.0), np.radians(90.0), 1000.0)
+    >>> lat2, lon2, alt2 = ecef_to_geodetic(x, y, z)
+    >>> np.degrees(lat2), np.degrees(lon2), alt2
+    (45.0..., 90.0..., 1000.0...)
+
     Notes
     -----
     Uses Bowring's iterative algorithm for robust conversion.
@@ -409,12 +431,19 @@ def ecef_to_enu(
 
     Examples
     --------
-    >>> # Reference point
+    >>> import numpy as np
+    >>> # Reference point: Philadelphia
     >>> lat_ref, lon_ref, alt_ref = np.radians(40.0), np.radians(-75.0), 0.0
-    >>> # Target point (1 km east)
+    >>> # Target point slightly east
     >>> lat, lon, alt = np.radians(40.0), np.radians(-74.99), 0.0
     >>> x, y, z = geodetic_to_ecef(lat, lon, alt)
     >>> e, n, u = ecef_to_enu(x, y, z, lat_ref, lon_ref, alt_ref)
+    >>> e  # East displacement in meters
+    850...
+    >>> abs(n) < 10  # North displacement should be ~0
+    True
+    >>> abs(u) < 10  # Up displacement should be ~0
+    True
     """
     x = np.asarray(x, dtype=np.float64)
     y = np.asarray(y, dtype=np.float64)
@@ -471,6 +500,18 @@ def enu_to_ecef(
     -------
     x, y, z : ndarray
         ECEF coordinates in meters.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Reference point
+    >>> lat_ref, lon_ref, alt_ref = np.radians(40.0), np.radians(-75.0), 0.0
+    >>> # 1 km east, 500 m north, 100 m up
+    >>> x, y, z = enu_to_ecef(1000.0, 500.0, 100.0, lat_ref, lon_ref, alt_ref)
+    >>> # Convert back to verify
+    >>> e, n, u = ecef_to_enu(x, y, z, lat_ref, lon_ref, alt_ref)
+    >>> e, n, u
+    (1000.0..., 500.0..., 100.0...)
     """
     east = np.asarray(east, dtype=np.float64)
     north = np.asarray(north, dtype=np.float64)
@@ -522,6 +563,17 @@ def ecef_to_ned(
     -------
     north, east, down : ndarray
         NED coordinates in meters relative to reference point.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Reference point
+    >>> lat_ref, lon_ref, alt_ref = np.radians(40.0), np.radians(-75.0), 0.0
+    >>> # Target above reference
+    >>> x, y, z = geodetic_to_ecef(lat_ref, lon_ref, 1000.0)  # 1km above
+    >>> n, e, d = ecef_to_ned(x, y, z, lat_ref, lon_ref, alt_ref)
+    >>> abs(n) < 1, abs(e) < 1, d  # Should be ~0, ~0, -1000
+    (True, True, -1000.0...)
     """
     east, north, up = ecef_to_enu(x, y, z, lat_ref, lon_ref, alt_ref, ellipsoid)
     return north, east, -up
@@ -556,6 +608,17 @@ def ned_to_ecef(
     -------
     x, y, z : ndarray
         ECEF coordinates in meters.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat_ref, lon_ref, alt_ref = np.radians(40.0), np.radians(-75.0), 0.0
+    >>> # 100m north, 50m east, 10m down
+    >>> x, y, z = ned_to_ecef(100.0, 50.0, 10.0, lat_ref, lon_ref, alt_ref)
+    >>> # Verify round-trip
+    >>> n, e, d = ecef_to_ned(x, y, z, lat_ref, lon_ref, alt_ref)
+    >>> n, e, d
+    (100.0..., 50.0..., 10.0...)
     """
     return enu_to_ecef(
         east, north, -np.asarray(down), lat_ref, lon_ref, alt_ref, ellipsoid
@@ -597,6 +660,17 @@ def direct_geodetic(
     azimuth2 : float
         Back azimuth at destination in radians.
 
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # From New York, travel 1000 km northeast
+    >>> lat1, lon1 = np.radians(40.7), np.radians(-74.0)
+    >>> azimuth = np.radians(45)  # Northeast
+    >>> distance = 1_000_000  # 1000 km
+    >>> lat2, lon2, az2 = direct_geodetic(lat1, lon1, azimuth, distance)
+    >>> np.degrees(lat2), np.degrees(lon2)  # Destination
+    (47.0..., -62.6...)
+
     References
     ----------
     .. [1] Vincenty, T., "Direct and Inverse Solutions of Geodesics on the
@@ -647,6 +721,18 @@ def inverse_geodetic(
     azimuth2 : float
         Back azimuth at destination in radians.
 
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Distance from New York to London
+    >>> lat1, lon1 = np.radians(40.7128), np.radians(-74.0060)  # NYC
+    >>> lat2, lon2 = np.radians(51.5074), np.radians(-0.1278)   # London
+    >>> dist, az1, az2 = inverse_geodetic(lat1, lon1, lat2, lon2)
+    >>> dist / 1000  # Distance in km
+    5570...
+    >>> np.degrees(az1)  # Initial heading from NYC
+    51.2...
+
     Notes
     -----
     May fail to converge for nearly antipodal points.
@@ -690,6 +776,19 @@ def haversine_distance(
     float
         Great-circle distance in meters.
 
+    Examples
+    --------
+    >>> import numpy as np
+    >>> # Distance from equator to 45°N along prime meridian
+    >>> lat1, lon1 = 0.0, 0.0
+    >>> lat2, lon2 = np.radians(45.0), 0.0
+    >>> dist = haversine_distance(lat1, lon1, lat2, lon2)
+    >>> dist / 1000  # ~5000 km
+    5003...
+    >>> # Same point -> 0 distance
+    >>> haversine_distance(0.0, 0.0, 0.0, 0.0)
+    0.0
+
     Notes
     -----
     This is a spherical approximation. For higher accuracy on an ellipsoid,

pytcl/navigation/great_circle.py

@@ -260,6 +260,14 @@ def great_circle_inverse(
     -------
     GreatCircleResult
         Distance and azimuths.
+
+    Examples
+    --------
+    >>> lat1, lon1 = np.radians(40.7128), np.radians(-74.0060)  # NYC
+    >>> lat2, lon2 = np.radians(51.5074), np.radians(-0.1278)   # London
+    >>> result = great_circle_inverse(lat1, lon1, lat2, lon2)
+    >>> result.distance > 5000000  # Over 5000 km
+    True
     """
     distance = great_circle_distance(lat1, lon1, lat2, lon2, radius)
     azimuth1 = great_circle_azimuth(lat1, lon1, lat2, lon2)
@@ -346,6 +354,14 @@ def great_circle_waypoints(
     -------
     lats, lons : ndarray
         Arrays of waypoint latitudes and longitudes in radians.
+
+    Examples
+    --------
+    >>> lat1, lon1 = 0.0, 0.0
+    >>> lat2, lon2 = np.pi/4, np.pi/4
+    >>> lats, lons = great_circle_waypoints(lat1, lon1, lat2, lon2, 5)
+    >>> len(lats)
+    5
     """
     fractions = np.linspace(0, 1, n_points)
     lats = np.zeros(n_points)
@@ -448,6 +464,16 @@ def cross_track_distance(
     -----
     Positive cross-track means the point is to the right of the path
     (when traveling from start to end).
+
+    Examples
+    --------
+    >>> # Point near a path from origin to northeast
+    >>> lat_pt, lon_pt = np.radians(5), np.radians(2)
+    >>> lat1, lon1 = 0.0, 0.0
+    >>> lat2, lon2 = np.radians(10), np.radians(10)
+    >>> result = cross_track_distance(lat_pt, lon_pt, lat1, lon1, lat2, lon2)
+    >>> abs(result.cross_track) < 500000  # Within 500 km
+    True
     """
     # Angular distance from start to point
     d13 = great_circle_distance(lat1, lon1, lat_point, lon_point, radius=1.0)
@@ -502,6 +528,16 @@ def great_circle_intersect(
     Great circles always intersect at two antipodal points (unless they
     are identical or parallel). The returned points are the intersections
     closest to the given points.
+
+    Examples
+    --------
+    >>> lat1, lon1 = 0.0, 0.0
+    >>> az1 = np.radians(45)  # Northeast
+    >>> lat2, lon2 = 0.0, np.radians(10)
+    >>> az2 = np.radians(315)  # Northwest
+    >>> result = great_circle_intersect(lat1, lon1, az1, lat2, lon2, az2)
+    >>> result.valid
+    True
     """
 
     # Convert to Cartesian unit vectors
@@ -595,6 +631,16 @@ def great_circle_path_intersect(
     -------
     IntersectionResult
         Intersection points and validity.
+
+    Examples
+    --------
+    >>> # Two crossing paths
+    >>> result = great_circle_path_intersect(
+    ...     0.0, 0.0, np.radians(10), np.radians(10),  # Path A
+    ...     0.0, np.radians(10), np.radians(10), 0.0    # Path B
+    ... )
+    >>> result.valid
+    True
     """
     # Get bearings from start points
     az1 = great_circle_azimuth(lat1a, lon1a, lat2a, lon2a)
@@ -783,6 +829,22 @@ def angular_distance(
     -------
     float
         Angular distance in radians.
+
+    Examples
+    --------
+    Compute angular distance between New York and London:
+
+    >>> import numpy as np
+    >>> # NYC: 40.7°N, 74.0°W; London: 51.5°N, 0.1°W
+    >>> lat1, lon1 = np.radians(40.7), np.radians(-74.0)
+    >>> lat2, lon2 = np.radians(51.5), np.radians(-0.1)
+    >>> angle = angular_distance(lat1, lon1, lat2, lon2)
+    >>> np.degrees(angle)  # about 50 degrees
+    49.9...
+
+    See Also
+    --------
+    great_circle_distance : Compute distance on sphere with given radius.
     """
     return great_circle_distance(lat1, lon1, lat2, lon2, radius=1.0)
 
@@ -809,6 +871,15 @@ def destination_point(
     -------
     WaypointResult
         Destination coordinates.
+
+    Examples
+    --------
+    >>> lat, lon = 0.0, 0.0
+    >>> bearing = np.radians(90)  # Due East
+    >>> ang_dist = np.radians(10)  # 10 degrees
+    >>> dest = destination_point(lat, lon, bearing, ang_dist)
+    >>> np.degrees(dest.lon)  # Should be ~10 degrees East
+    10.0
     """
     lat2 = np.arcsin(
         np.sin(lat) * np.cos(angular_distance)

pytcl/navigation/rhumb.py

@@ -263,6 +263,15 @@ def indirect_rhumb_spherical(
     -------
     RhumbResult
         Distance and constant bearing.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(40), np.radians(-74)  # New York
+    >>> lat2, lon2 = np.radians(51), np.radians(0)   # London
+    >>> result = indirect_rhumb_spherical(lat1, lon1, lat2, lon2)
+    >>> result.distance > 5000000  # Over 5000 km
+    True
     """
     distance = rhumb_distance_spherical(lat1, lon1, lat2, lon2, radius)
     bearing = rhumb_bearing(lat1, lon1, lat2, lon2)
@@ -354,6 +363,15 @@ def rhumb_distance_ellipsoidal(
     -------
     float
         Rhumb line distance in meters.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(40), np.radians(-74)
+    >>> lat2, lon2 = np.radians(51), np.radians(0)
+    >>> dist = rhumb_distance_ellipsoidal(lat1, lon1, lat2, lon2)
+    >>> dist > 5000000  # Over 5000 km
+    True
     """
     a = ellipsoid.a
     e2 = ellipsoid.e2
@@ -419,6 +437,15 @@ def indirect_rhumb(
     -------
     RhumbResult
         Distance and constant bearing.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(40), np.radians(-74)  # New York
+    >>> lat2, lon2 = np.radians(51), np.radians(0)   # London
+    >>> result = indirect_rhumb(lat1, lon1, lat2, lon2)
+    >>> 0 < result.bearing < np.pi  # Eastward bearing
+    True
     """
     distance = rhumb_distance_ellipsoidal(lat1, lon1, lat2, lon2, ellipsoid)
 
@@ -460,6 +487,15 @@ def direct_rhumb(
     -------
     RhumbDirectResult
         Destination latitude and longitude.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat, lon = np.radians(40), np.radians(-74)
+    >>> bearing = np.radians(90)  # Due east
+    >>> dest = direct_rhumb(lat, lon, bearing, 100000)  # 100 km
+    >>> np.degrees(dest.lon) > -74  # Moved east
+    True
     """
     a = ellipsoid.a
     e2 = ellipsoid.e2
@@ -534,6 +570,17 @@ def rhumb_intersect(
     RhumbIntersectionResult
         Intersection point and validity flag.
 
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(40), np.radians(-74)
+    >>> lat2, lon2 = np.radians(51), np.radians(0)
+    >>> bearing1 = np.radians(45)
+    >>> bearing2 = np.radians(270)
+    >>> result = rhumb_intersect(lat1, lon1, bearing1, lat2, lon2, bearing2)
+    >>> result.valid  # May or may not intersect
+    True
+
     Notes
     -----
     Unlike great circles, two rhumb lines may not intersect (if bearings
@@ -612,6 +659,15 @@ def rhumb_midpoint(
     -------
     RhumbDirectResult
         Midpoint latitude and longitude.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(0), np.radians(0)
+    >>> lat2, lon2 = np.radians(10), np.radians(10)
+    >>> mid = rhumb_midpoint(lat1, lon1, lat2, lon2)
+    >>> np.isclose(np.degrees(mid.lat), 5, atol=0.1)
+    True
     """
     result = indirect_rhumb_spherical(lat1, lon1, lat2, lon2)
     return direct_rhumb_spherical(lat1, lon1, result.bearing, result.distance / 2)
@@ -643,6 +699,15 @@ def rhumb_waypoints(
     -------
     lats, lons : ndarray
         Arrays of waypoint latitudes and longitudes in radians.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(40), np.radians(-74)
+    >>> lat2, lon2 = np.radians(51), np.radians(0)
+    >>> lats, lons = rhumb_waypoints(lat1, lon1, lat2, lon2, 5)
+    >>> len(lats)
+    5
     """
     result = indirect_rhumb_spherical(lat1, lon1, lat2, lon2, radius)
 
@@ -685,6 +750,15 @@ def compare_great_circle_rhumb(
         Rhumb line distance in meters.
     difference_percent : float
         Percentage difference (rhumb is longer).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> lat1, lon1 = np.radians(40), np.radians(-74)  # NYC
+    >>> lat2, lon2 = np.radians(51), np.radians(0)   # London
+    >>> gc, rhumb, diff = compare_great_circle_rhumb(lat1, lon1, lat2, lon2)
+    >>> rhumb > gc  # Rhumb is always longer
+    True
     """
     from pytcl.navigation.great_circle import great_circle_distance
 

pytcl/performance_evaluation/estimation_metrics.py

@@ -140,6 +140,14 @@ def velocity_rmse(
     -------
     float
         Velocity RMSE.
+
+    Examples
+    --------
+    >>> # State = [x, vx, y, vy], velocities are indices [1, 3]
+    >>> true = np.array([[0, 10, 0, 5], [1, 10, 0.5, 5]])
+    >>> est = np.array([[0, 9.5, 0, 5.2], [1, 10.2, 0.5, 4.9]])
+    >>> velocity_rmse(true, est, [1, 3])  # doctest: +SKIP
+    0.316...
     """
     true_vel = true_states[:, velocity_indices]
     est_vel = estimated_states[:, velocity_indices]
@@ -216,6 +224,15 @@ def nees_sequence(
     -------
     ndarray
         NEES values for each time step, shape (N,).
+
+    Examples
+    --------
+    >>> true = np.array([[1.0, 2.0], [1.5, 2.5]])
+    >>> est = np.array([[1.1, 1.9], [1.6, 2.4]])
+    >>> P = np.array([np.eye(2) * 0.1, np.eye(2) * 0.1])
+    >>> nees_vals = nees_sequence(true, est, P)
+    >>> len(nees_vals)
+    2
     """
     N = true_states.shape[0]
     nees_values = np.zeros(N)
@@ -247,6 +264,15 @@ def average_nees(
     -------
     float
         Average NEES (should be close to state_dim for consistent filter).
+
+    Examples
+    --------
+    >>> true = np.array([[1.0, 2.0], [1.5, 2.5], [2.0, 3.0]])
+    >>> est = np.array([[1.1, 1.9], [1.6, 2.4], [2.1, 2.9]])
+    >>> P = np.array([np.eye(2) * 0.1] * 3)
+    >>> avg = average_nees(true, est, P)
+    >>> avg  # Should be close to state_dim=2 for consistent filter
+    0.2
     """
     return float(np.mean(nees_sequence(true_states, estimated_states, covariances)))
 
@@ -279,6 +305,13 @@ def nis(
 
     where nu = z - H*x_pred is the innovation and S is the innovation
     covariance.
+
+    Examples
+    --------
+    >>> nu = np.array([0.5, -0.3])  # Innovation vector
+    >>> S = np.eye(2) * 0.25  # Innovation covariance
+    >>> nis(nu, S)
+    1.36
     """
     innovation = np.asarray(innovation)
     innovation_covariance = np.asarray(innovation_covariance)
@@ -305,6 +338,14 @@ def nis_sequence(
     -------
     ndarray
         NIS values for each time step.
+
+    Examples
+    --------
+    >>> innovations = np.array([[0.5, -0.3], [0.2, 0.1]])
+    >>> S = np.array([np.eye(2) * 0.25, np.eye(2) * 0.25])
+    >>> nis_vals = nis_sequence(innovations, S)
+    >>> len(nis_vals)
+    2
     """
     N = innovations.shape[0]
     nis_values = np.zeros(N)
@@ -395,6 +436,15 @@ def credibility_interval(
     -------
     float
         Fraction of errors within the interval.
+
+    Examples
+    --------
+    >>> rng = np.random.default_rng(42)
+    >>> errors = rng.normal(0, 0.1, (100, 2))  # Small errors
+    >>> P = np.array([np.eye(2) * 0.1] * 100)  # Matching covariance
+    >>> frac = credibility_interval(errors, P, interval=0.95)
+    >>> frac > 0.9  # Most errors within interval
+    True
     """
     N = len(errors)
     state_dim = errors.shape[1]
@@ -430,6 +480,16 @@ def monte_carlo_rmse(
     -------
     ndarray
         RMSE values.
+
+    Examples
+    --------
+    >>> # 3 Monte Carlo runs, 2 time steps, 2 state components
+    >>> errors = np.array([[[0.1, 0.2], [0.15, 0.1]],
+    ...                    [[0.05, 0.1], [0.2, 0.15]],
+    ...                    [[0.15, 0.05], [0.1, 0.2]]])
+    >>> rmse_per_time = monte_carlo_rmse(errors, axis=0)
+    >>> rmse_per_time.shape
+    (2, 2)
     """
     return np.sqrt(np.mean(errors**2, axis=axis))
 
@@ -453,6 +513,16 @@ def estimation_error_bounds(
     ndarray
         Error bounds (standard deviations) for each component,
         shape (N, state_dim).
+
+    Examples
+    --------
+    >>> P = np.array([[[1.0, 0], [0, 4.0]],
+    ...               [[0.25, 0], [0, 1.0]]])
+    >>> bounds = estimation_error_bounds(P, sigma=2.0)
+    >>> bounds[0]  # 2-sigma bounds: 2*sqrt(1), 2*sqrt(4)
+    array([2., 4.])
+    >>> bounds[1]  # 2-sigma bounds: 2*sqrt(0.25), 2*sqrt(1)
+    array([1., 2.])
     """
     # Extract diagonal elements (variances)
     variances = np.diagonal(covariances, axis1=1, axis2=2)