nrl-tracker 0.20.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

{nrl_tracker-0.20.0.dist-info → nrl_tracker-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nrl-tracker
-Version: 0.20.0
+Version: 0.21.0
 Summary: Python port of the U.S. Naval Research Laboratory's Tracker Component Library for target tracking algorithms
 Author: Original: David F. Crouse, Naval Research Laboratory
 Maintainer: Python Port Contributors

{nrl_tracker-0.20.0.dist-info → nrl_tracker-0.21.0.dist-info}/RECORD

@@ -88,17 +88,21 @@ pytcl/mathematical_functions/geometry/geometry.py,sha256=l63wQnhCtJwVHZOJeONX1qy
 pytcl/mathematical_functions/interpolation/__init__.py,sha256=HDhP7ZsgUrXFBNJ_eCZEdp5gizWJ-BxvkQSCMnvBg3A,677
 pytcl/mathematical_functions/interpolation/interpolation.py,sha256=2cXMDgWBjWDGHnK1K_lawFlJL8oPl5AQGf9MNgsESfo,12610
 pytcl/mathematical_functions/numerical_integration/__init__.py,sha256=iXiHzyV_KIhCv7tXErXlN1_fUEACN6yN3CYDHRA7esw,974
-pytcl/mathematical_functions/numerical_integration/quadrature.py,sha256=ErxG_HLfM2LjKStguK_2wEhodln63v1FVubetAS5GL0,14748
+pytcl/mathematical_functions/numerical_integration/quadrature.py,sha256=ZRMKs0vbcgFDe1Sr8sjyEOkALLmJU4zKRJjoPEcXrUc,15670
 pytcl/mathematical_functions/polynomials/__init__.py,sha256=WJWZcoQhnvy5f59-kncMTgD9mCtgwfDgULvDYYHS5ys,43
 pytcl/mathematical_functions/signal_processing/__init__.py,sha256=_SzzBVtxmSvP8FKeogRdNmFo8FOVDDoexVOqd-lE7do,2325
 pytcl/mathematical_functions/signal_processing/detection.py,sha256=9F0xdy3hMat1czSWAQYMExn0kY5DBRpyBneAfjjHUVI,30377
 pytcl/mathematical_functions/signal_processing/filters.py,sha256=8Ojf4h4rfiucBXqUmB1odvHH41Gf3rPwmWCMKb-qzWk,23435
 pytcl/mathematical_functions/signal_processing/matched_filter.py,sha256=AahJZRZk2IIXzRL7www0n8bc0XoKabaLOe8yYNSjuDY,22893
-pytcl/mathematical_functions/special_functions/__init__.py,sha256=fXACpf-y1Jdq7UmVjwETUVhN_mkATT1I4tKbT1FW-C0,2017
-pytcl/mathematical_functions/special_functions/bessel.py,sha256=0sVwL1pPqNYiVkjXqacnkHoPBkiomk0D7IDu6-bKtEs,8139
+pytcl/mathematical_functions/special_functions/__init__.py,sha256=qDPGfee1i1NkVi9LXJKnsWXL3CWHkPQINrkwqLqB8YU,3796
+pytcl/mathematical_functions/special_functions/bessel.py,sha256=M0mwLQBaUXEHA8wyKReJ2D66I1v1XR7y-txAipd-WDs,14377
+pytcl/mathematical_functions/special_functions/debye.py,sha256=Nchjwkl1vzSL1L7nQpslb-lvT49LgTfdTIQMeSNn4vQ,6689
 pytcl/mathematical_functions/special_functions/elliptic.py,sha256=WyzBkrfZufIR5dUmCKGcxp6KNpVDrU89NGLDyRrZOqQ,7418
 pytcl/mathematical_functions/special_functions/error_functions.py,sha256=a3SS8FYAMRv1KdCmebOZL95yjvVt9gZRF2XOjHvQ9M8,6253
 pytcl/mathematical_functions/special_functions/gamma_functions.py,sha256=xXN_9SCokH10HjE8PpaPKHYVK_RZRHRAbZgR2mZYIAA,10191
+pytcl/mathematical_functions/special_functions/hypergeometric.py,sha256=gKn_tXboEst7pVDiW15IbKFAANM4XVqKtDc1dmWL-2A,9768
+pytcl/mathematical_functions/special_functions/lambert_w.py,sha256=ivRc4KH5Lwoxb_yijrJEwG0ITa0hhcYF7_gCfVBBNW4,6855
+pytcl/mathematical_functions/special_functions/marcum_q.py,sha256=OZ5QjIB1e_XvRG8A-3dbZ13YXHtdk2EYVEPaqtgVr14,9580
 pytcl/mathematical_functions/statistics/__init__.py,sha256=dfypStgmnFmOrnWcm-3CEvLinONHraFgx9O66_37bqw,1278
 pytcl/mathematical_functions/statistics/distributions.py,sha256=icfFIIKCEFzkpFHuYGWL197nm8wvS7UPJlr9kd_uEgw,19373
 pytcl/mathematical_functions/statistics/estimators.py,sha256=TLnYXSwk5MzBakZrzDBupbOB3ONmJI7q1-oB2xuSVQM,10831
@@ -137,8 +141,8 @@ pytcl/trackers/mht.py,sha256=7mwhMmja3ri2wnx7W1wueDGn2r3ArwAxJDPUJ7IZAkQ,20617
 pytcl/trackers/multi_target.py,sha256=7ZL8V25TO_rEMtQm2eYkScesDQHC9qXZVHLHyVbxy3M,10529
 pytcl/trackers/single_target.py,sha256=Yy3FwaNTArMWcaod-0HVeiioNV4xLWxNDn_7ZPVqQYs,6562
 pytcl/transponders/__init__.py,sha256=5fL4u3lKCYgPLo5uFeuZbtRZkJPABntuKYGUvVgMMEI,41
-nrl_tracker-0.20.0.dist-info/LICENSE,sha256=rB5G4WppIIUzMOYr2N6uyYlNJ00hRJqE5tie6BMvYuE,1612
-nrl_tracker-0.20.0.dist-info/METADATA,sha256=5ObdsLBjNtHmUoVDxkzrARr4ITlJz4nyzm-ysPNZOvs,9699
-nrl_tracker-0.20.0.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
-nrl_tracker-0.20.0.dist-info/top_level.txt,sha256=17megxcrTPBWwPZTh6jTkwTKxX7No-ZqRpyvElnnO-s,6
-nrl_tracker-0.20.0.dist-info/RECORD,,
+nrl_tracker-0.21.0.dist-info/LICENSE,sha256=rB5G4WppIIUzMOYr2N6uyYlNJ00hRJqE5tie6BMvYuE,1612
+nrl_tracker-0.21.0.dist-info/METADATA,sha256=eDRPYJpt_3_IysLZ1cPPhRikpdZmtCd_1EF8Fmfyq6M,9699
+nrl_tracker-0.21.0.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
+nrl_tracker-0.21.0.dist-info/top_level.txt,sha256=17megxcrTPBWwPZTh6jTkwTKxX7No-ZqRpyvElnnO-s,6
+nrl_tracker-0.21.0.dist-info/RECORD,,

pytcl/mathematical_functions/numerical_integration/quadrature.py

@@ -336,7 +336,8 @@ def romberg(
     f: Callable[[float], float],
     a: float,
     b: float,
-    **kwargs,
+    tol: float = 1e-8,
+    max_steps: int = 20,
 ) -> float:
     """
     Romberg integration.
@@ -351,19 +352,47 @@ def romberg(
         Lower limit.
     b : float
         Upper limit.
-    **kwargs
-        Additional arguments passed to scipy.integrate.romberg.
+    tol : float, optional
+        Desired tolerance. Default is 1e-8.
+    max_steps : int, optional
+        Maximum number of extrapolation steps. Default is 20.
 
     Returns
     -------
     result : float
         Estimated integral value.
 
-    See Also
-    --------
-    scipy.integrate.romberg : Underlying implementation.
+    Notes
+    -----
+    This is a native implementation that does not depend on scipy.integrate.romberg,
+    which was deprecated in scipy 1.12 and removed in scipy 1.15.
     """
-    return float(integrate.romberg(f, a, b, **kwargs))
+    # Romberg table
+    R = np.zeros((max_steps, max_steps), dtype=np.float64)
+
+    h = b - a
+    R[0, 0] = 0.5 * h * (f(a) + f(b))
+
+    for i in range(1, max_steps):
+        h = h / 2.0
+
+        # Composite trapezoidal rule with 2^i intervals
+        n_new = 2 ** (i - 1)
+        total = 0.0
+        for k in range(1, n_new + 1):
+            total += f(a + (2 * k - 1) * h)
+        R[i, 0] = 0.5 * R[i - 1, 0] + h * total
+
+        # Richardson extrapolation
+        for j in range(1, i + 1):
+            factor = 4**j
+            R[i, j] = (factor * R[i, j - 1] - R[i - 1, j - 1]) / (factor - 1)
+
+        # Check convergence
+        if i > 0 and abs(R[i, i] - R[i - 1, i - 1]) < tol:
+            return float(R[i, i])
+
+    return float(R[max_steps - 1, max_steps - 1])
 
 
 def simpson(

pytcl/mathematical_functions/special_functions/__init__.py

@@ -7,19 +7,38 @@ physics, signal processing, and statistical applications:
 - Gamma and beta functions
 - Error functions
 - Elliptic integrals
+- Marcum Q function (radar detection)
+- Hypergeometric functions
+- Lambert W function
+- Debye functions (thermodynamics)
 """
 
 from pytcl.mathematical_functions.special_functions.bessel import (
     airy,
+    bessel_deriv,
+    bessel_ratio,
+    bessel_zeros,
     besselh,
     besseli,
     besselj,
     besselk,
     bessely,
+    kelvin,
     spherical_in,
     spherical_jn,
     spherical_kn,
     spherical_yn,
+    struve_h,
+    struve_l,
+)
+from pytcl.mathematical_functions.special_functions.debye import (
+    debye,
+    debye_1,
+    debye_2,
+    debye_3,
+    debye_4,
+    debye_entropy,
+    debye_heat_capacity,
 )
 from pytcl.mathematical_functions.special_functions.elliptic import (  # noqa: E501
     ellipe,
@@ -62,6 +81,32 @@ from pytcl.mathematical_functions.special_functions.gamma_functions import (  #
     perm,
     polygamma,
 )
+from pytcl.mathematical_functions.special_functions.hypergeometric import (
+    falling_factorial,
+    generalized_hypergeometric,
+    hyp0f1,
+    hyp1f1,
+    hyp1f1_regularized,
+    hyp2f1,
+    hyperu,
+    pochhammer,
+)
+from pytcl.mathematical_functions.special_functions.lambert_w import (
+    lambert_w,
+    lambert_w_real,
+    omega_constant,
+    solve_exponential_equation,
+    time_delay_equation,
+    wright_omega,
+)
+from pytcl.mathematical_functions.special_functions.marcum_q import (
+    log_marcum_q,
+    marcum_q,
+    marcum_q1,
+    marcum_q_inv,
+    nuttall_q,
+    swerling_detection_probability,
+)
 
 __all__ = [
     # Bessel functions
@@ -75,6 +120,12 @@ __all__ = [
     "spherical_in",
     "spherical_kn",
     "airy",
+    "bessel_ratio",
+    "bessel_deriv",
+    "bessel_zeros",
+    "struve_h",
+    "struve_l",
+    "kelvin",
     # Gamma functions
     "gamma",
     "gammaln",
@@ -113,4 +164,35 @@ __all__ = [
     "elliprg",
     "elliprj",
     "elliprc",
+    # Marcum Q function (radar detection)
+    "marcum_q",
+    "marcum_q1",
+    "log_marcum_q",
+    "marcum_q_inv",
+    "nuttall_q",
+    "swerling_detection_probability",
+    # Lambert W function
+    "lambert_w",
+    "lambert_w_real",
+    "omega_constant",
+    "wright_omega",
+    "solve_exponential_equation",
+    "time_delay_equation",
+    # Debye functions
+    "debye",
+    "debye_1",
+    "debye_2",
+    "debye_3",
+    "debye_4",
+    "debye_heat_capacity",
+    "debye_entropy",
+    # Hypergeometric functions
+    "hyp0f1",
+    "hyp1f1",
+    "hyp2f1",
+    "hyperu",
+    "hyp1f1_regularized",
+    "pochhammer",
+    "falling_factorial",
+    "generalized_hypergeometric",
 ]

pytcl/mathematical_functions/special_functions/bessel.py

@@ -345,6 +345,260 @@ def airy(x: ArrayLike) -> tuple:
     return tuple(np.asarray(r, dtype=np.float64) for r in result)
 
 
+def bessel_ratio(
+    n: Union[int, float],
+    x: ArrayLike,
+    kind: str = "j",
+) -> NDArray[np.floating]:
+    """
+    Ratio of Bessel functions J_{n+1}(x) / J_n(x) or I_{n+1}(x) / I_n(x).
+
+    Parameters
+    ----------
+    n : int or float
+        Order of the Bessel function in the denominator.
+    x : array_like
+        Argument of the Bessel function.
+    kind : str, optional
+        Type of Bessel function: 'j' for J_n, 'i' for I_n. Default is 'j'.
+
+    Returns
+    -------
+    ratio : ndarray
+        Values of J_{n+1}(x) / J_n(x) or I_{n+1}(x) / I_n(x).
+
+    Notes
+    -----
+    Uses the recurrence relation for numerical stability:
+    J_{n+1}(x) / J_n(x) = 2n/x - 1/(J_n(x)/J_{n-1}(x))
+
+    Examples
+    --------
+    >>> bessel_ratio(0, 1)  # J_1(1) / J_0(1)
+    0.5767...
+    """
+    x = np.asarray(x, dtype=np.float64)
+
+    if kind.lower() == "j":
+        num = sp.jv(n + 1, x)
+        den = sp.jv(n, x)
+    elif kind.lower() == "i":
+        num = sp.iv(n + 1, x)
+        den = sp.iv(n, x)
+    else:
+        raise ValueError(f"kind must be 'j' or 'i', got '{kind}'")
+
+    # Handle zeros in denominator
+    with np.errstate(divide="ignore", invalid="ignore"):
+        ratio = np.where(den != 0, num / den, np.inf * np.sign(num))
+
+    return np.asarray(ratio, dtype=np.float64)
+
+
+def bessel_deriv(
+    n: Union[int, float],
+    x: ArrayLike,
+    kind: str = "j",
+) -> NDArray[np.floating]:
+    """
+    Derivative of Bessel function d/dx[B_n(x)].
+
+    Parameters
+    ----------
+    n : int or float
+        Order of the Bessel function.
+    x : array_like
+        Argument of the Bessel function.
+    kind : str, optional
+        Type of Bessel function: 'j', 'y', 'i', or 'k'. Default is 'j'.
+
+    Returns
+    -------
+    deriv : ndarray
+        Values of dB_n(x)/dx.
+
+    Notes
+    -----
+    Uses the identity:
+    dJ_n/dx = (J_{n-1}(x) - J_{n+1}(x)) / 2
+    dY_n/dx = (Y_{n-1}(x) - Y_{n+1}(x)) / 2
+    dI_n/dx = (I_{n-1}(x) + I_{n+1}(x)) / 2
+    dK_n/dx = -(K_{n-1}(x) + K_{n+1}(x)) / 2
+
+    Examples
+    --------
+    >>> bessel_deriv(0, 1, kind='j')  # -J_1(1)
+    -0.4400...
+    """
+    x = np.asarray(x, dtype=np.float64)
+
+    kind = kind.lower()
+    if kind == "j":
+        deriv = (sp.jv(n - 1, x) - sp.jv(n + 1, x)) / 2
+    elif kind == "y":
+        deriv = (sp.yv(n - 1, x) - sp.yv(n + 1, x)) / 2
+    elif kind == "i":
+        deriv = (sp.iv(n - 1, x) + sp.iv(n + 1, x)) / 2
+    elif kind == "k":
+        deriv = -(sp.kv(n - 1, x) + sp.kv(n + 1, x)) / 2
+    else:
+        raise ValueError(f"kind must be 'j', 'y', 'i', or 'k', got '{kind}'")
+
+    return np.asarray(deriv, dtype=np.float64)
+
+
+def struve_h(
+    n: Union[int, float],
+    x: ArrayLike,
+) -> NDArray[np.floating]:
+    """
+    Struve function H_n(x).
+
+    The Struve function is defined by the integral:
+    H_n(x) = (2/sqrt(pi)) * (x/2)^n * integral from 0 to pi/2 of
+             sin(x*cos(t)) * sin^(2n)(t) dt
+
+    Parameters
+    ----------
+    n : int or float
+        Order of the Struve function.
+    x : array_like
+        Argument of the function.
+
+    Returns
+    -------
+    H : ndarray
+        Values of H_n(x).
+
+    Notes
+    -----
+    Related to Bessel functions through:
+    H_0(x) is the particular solution of y'' + y'/x + y = 2/(pi*x)
+
+    Examples
+    --------
+    >>> struve_h(0, 1)
+    0.5688...
+    """
+    return np.asarray(sp.struve(n, x), dtype=np.float64)
+
+
+def struve_l(
+    n: Union[int, float],
+    x: ArrayLike,
+) -> NDArray[np.floating]:
+    """
+    Modified Struve function L_n(x).
+
+    The modified Struve function is related to the Struve function by:
+    L_n(x) = -i * exp(-i*n*pi/2) * H_n(i*x)
+
+    Parameters
+    ----------
+    n : int or float
+        Order of the modified Struve function.
+    x : array_like
+        Argument of the function.
+
+    Returns
+    -------
+    L : ndarray
+        Values of L_n(x).
+    """
+    return np.asarray(sp.modstruve(n, x), dtype=np.float64)
+
+
+def bessel_zeros(
+    n: int,
+    nt: int,
+    kind: str = "j",
+) -> NDArray[np.floating]:
+    """
+    Zeros of Bessel functions.
+
+    Computes the first nt zeros of J_n(x), Y_n(x), or their derivatives.
+
+    Parameters
+    ----------
+    n : int
+        Order of the Bessel function.
+    nt : int
+        Number of zeros to compute.
+    kind : str, optional
+        Type: 'j' for J_n zeros, 'y' for Y_n zeros,
+        'jp' for J_n' zeros, 'yp' for Y_n' zeros. Default is 'j'.
+
+    Returns
+    -------
+    zeros : ndarray
+        Array of zeros.
+
+    Examples
+    --------
+    >>> bessel_zeros(0, 3, kind='j')  # First 3 zeros of J_0
+    array([2.404..., 5.520..., 8.653...])
+    """
+    kind = kind.lower()
+
+    if kind == "j":
+        return np.asarray(sp.jn_zeros(n, nt), dtype=np.float64)
+    elif kind == "y":
+        return np.asarray(sp.yn_zeros(n, nt), dtype=np.float64)
+    elif kind == "jp":
+        return np.asarray(sp.jnp_zeros(n, nt), dtype=np.float64)
+    elif kind == "yp":
+        return np.asarray(sp.ynp_zeros(n, nt), dtype=np.float64)
+    else:
+        raise ValueError(f"kind must be 'j', 'y', 'jp', or 'yp', got '{kind}'")
+
+
+def kelvin(
+    x: ArrayLike,
+) -> tuple:
+    """
+    Kelvin functions ber, bei, ker, kei.
+
+    Kelvin functions are the real and imaginary parts of the
+    Bessel functions with argument x*exp(3*pi*i/4).
+
+    Parameters
+    ----------
+    x : array_like
+        Argument of the Kelvin functions.
+
+    Returns
+    -------
+    ber : ndarray
+        Kelvin function ber(x).
+    bei : ndarray
+        Kelvin function bei(x).
+    ker : ndarray
+        Kelvin function ker(x).
+    kei : ndarray
+        Kelvin function kei(x).
+
+    Notes
+    -----
+    ber(x) + i*bei(x) = J_0(x * exp(3*pi*i/4))
+    ker(x) + i*kei(x) = K_0(x * exp(pi*i/4))
+
+    Examples
+    --------
+    >>> ber, bei, ker, kei = kelvin(1)
+    >>> ber
+    0.984...
+    """
+    x = np.asarray(x, dtype=np.float64)
+
+    # Use the individual scipy Kelvin functions for real-valued results
+    ber = np.asarray(sp.ber(x), dtype=np.float64)
+    bei = np.asarray(sp.bei(x), dtype=np.float64)
+    ker = np.asarray(sp.ker(x), dtype=np.float64)
+    kei = np.asarray(sp.kei(x), dtype=np.float64)
+
+    return ber, bei, ker, kei
+
+
 __all__ = [
     "besselj",
     "bessely",
@@ -356,4 +610,10 @@ __all__ = [
     "spherical_in",
     "spherical_kn",
     "airy",
+    "bessel_ratio",
+    "bessel_deriv",
+    "struve_h",
+    "struve_l",
+    "bessel_zeros",
+    "kelvin",
 ]