elliptic-functions 4.0.0__py3-none-any.whl

elliptic/__init__.py

@@ -0,0 +1,101 @@
+"""elliptic — Elliptic integrals and functions for NumPy, PyTorch, and JAX.
+
+Standalone implementation (no scipy runtime dependency).
+Pass a torch.Tensor or jax.Array for automatic GPU/TPU dispatch.
+
+Public API
+----------
+Incomplete integrals:
+    elliptic12(u, m)             -> F, E, Z
+    elliptic3(u, m, n)           -> Pi
+    elliptic12i(u, m)            -> Fi, Ei, Zi  (complex u)
+
+Jacobi elliptic functions:
+    ellipj(u, m)                 -> sn, cn, dn, am
+    ellipji(u, m)                -> sn, cn, dn  (complex u)
+
+Associate integrals (incomplete):
+    ellipticBDJ(phi, m[, n])     -> B, D, J
+
+Complete associate integrals:
+    ellipticBD(m)                -> B, D, S
+
+Jacobi-argument forms:
+    jacobiEDJ(u, m[, n])         -> Eu, Du, Ju
+
+Carlson symmetric forms:
+    carlsonRF(x, y, z)
+    carlsonRD(x, y, z)
+    carlsonRJ(x, y, z, p)
+    carlsonRC(x, y)
+
+Bulirsch generalised complete integrals:
+    cel(kc, p, a, b)
+    cel1(kc)
+    cel2(kc, a, b)
+    cel3(kc, p)
+
+Jacobi theta functions:
+    jacobiThetaEta(u, m)         -> Th, H
+    theta(j, v, m)               -> Th_j
+    theta_prime(j, v, m)         -> Th_j, dTh_j/dv
+
+Weierstrass functions:
+    weierstrassP(z, e1, e2, e3)
+    weierstrassZeta(z, e1, e2, e3)
+    weierstrassSigma(z, e1, e2, e3)
+    weierstrassPPrime(z, e1, e2, e3)
+    weierstrassInvariants(e1, e2, e3)  -> g2, g3, Delta
+
+Nome and inverse:
+    nomeq(m)                     -> q
+    inversenomeq(q)              -> m
+
+Inverse integral:
+    inverselliptic2(E, m)        -> phi
+
+AGM:
+    agm(a, b)                    -> agm(a, b)
+
+Applications:
+    arclength_ellipse(a, b[, theta0, theta1])
+"""
+
+from .elliptic12         import elliptic12
+from .elliptic3          import elliptic3
+from .ellipj             import ellipj
+from .ellipticBDJ        import ellipticBDJ
+from .ellipticBD         import ellipticBD
+from .jacobi_edj         import jacobiEDJ
+from .carlson            import carlsonRF, carlsonRD, carlsonRJ, carlsonRC
+from .bulirsch           import cel, cel1, cel2, cel3
+from .weierstrass        import (weierstrassP, weierstrassZeta, weierstrassSigma,
+                                  weierstrassPPrime, weierstrassInvariants)
+from .theta              import jacobiThetaEta, theta, theta_prime
+from .complex_elliptic   import elliptic12i, ellipji
+from .nome               import nomeq, inversenomeq
+from .inverse            import inverselliptic2
+from .agm                import agm
+from .applications       import arclength_ellipse
+
+__all__ = [
+    # integrals
+    "elliptic12", "elliptic3", "elliptic12i",
+    # Jacobi
+    "ellipj", "ellipji",
+    # associate
+    "ellipticBDJ", "ellipticBD", "jacobiEDJ",
+    # Carlson
+    "carlsonRF", "carlsonRD", "carlsonRJ", "carlsonRC",
+    # Bulirsch
+    "cel", "cel1", "cel2", "cel3",
+    # theta
+    "jacobiThetaEta", "theta", "theta_prime",
+    # Weierstrass
+    "weierstrassP", "weierstrassZeta", "weierstrassSigma",
+    "weierstrassPPrime", "weierstrassInvariants",
+    # nome / inverse
+    "nomeq", "inversenomeq", "inverselliptic2",
+    # misc
+    "agm", "arclength_ellipse",
+]

elliptic/_agm.py

@@ -0,0 +1,57 @@
+"""AGM kernel shared by elliptic12 and ellipj.
+
+All loops run a *fixed* 25 iterations so the code is JAX-traceable
+(no dynamic stopping condition). For float64 the AGM converges in at
+most ~25 halvings, so the extra no-op iterations cost nothing.
+"""
+from __future__ import annotations
+
+_AGM_ITERS = 25   # safe upper bound for float64
+
+
+def agm_coeffs(m, xp):
+    """Compute AGM sequences a, b, c of shape (N, _AGM_ITERS+1).
+
+    Returns
+    -------
+    a, b, c : (N, iters+1) arrays
+    n       : (N,) int array — converged iteration index per element
+    """
+    N = m.shape[0]
+    iters = _AGM_ITERS
+
+    # Allocate: we'll build columns one by one (works for numpy/torch/jax)
+    a = [xp.ones(N, dtype=xp.float64)]
+    b = [xp.sqrt(1.0 - m)]
+    c = [xp.sqrt(m)]
+
+    for _ in range(iters):
+        a_new = 0.5 * (a[-1] + b[-1])
+        b_new = xp.sqrt(a[-1] * b[-1])
+        c_new = 0.5 * (a[-1] - b[-1])
+        a.append(a_new)
+        b.append(b_new)
+        c.append(c_new)
+
+    return a, b, c
+
+
+def agm_n(c, xp):
+    """Return per-element convergence index n from the c sequence."""
+    import numpy as _np
+    # n[k] = first i where |c[i]| ≈ 0 (i.e., c[i+1] < eps)
+    eps = float(xp.finfo(xp.float64).eps) if hasattr(xp, 'finfo') else 2.2e-16
+    iters = len(c) - 1
+    # Build as numpy for indexing simplicity; convert back if needed
+    try:
+        c_np = _np.stack([_np.asarray(ci) for ci in c], axis=0)  # (iters+1, N)
+    except Exception:
+        c_np = _np.array([_np.array(ci) for ci in c])
+    N = c_np.shape[1]
+    n = _np.zeros(N, dtype=_np.intp)
+    for i in range(1, iters + 1):
+        just_converged = (abs(c_np[i]) <= eps) & (abs(c_np[i - 1]) > eps)
+        n[just_converged & (n == 0)] = i - 1
+    # anything still 0 gets maximum
+    n[n == 0] = iters - 1
+    return n

elliptic/_utils.py

@@ -0,0 +1,86 @@
+"""Shared utilities: backend detection, type coercion, parallel chunking."""
+from __future__ import annotations
+
+import os
+import math
+from concurrent.futures import ProcessPoolExecutor
+from typing import Any
+
+from array_api_compat import array_namespace, is_numpy_array
+import numpy as _np
+
+
+def get_xp(*args: Any):
+    """Return the array namespace for the inputs (numpy, torch, jax.numpy, …).
+
+    Scalars and Python lists are treated as numpy by default.
+    """
+    # Convert any non-array args to numpy so array_namespace can detect them
+    converted = []
+    for a in args:
+        if isinstance(a, _np.ndarray):
+            converted.append(a)
+        else:
+            try:
+                # torch.Tensor, jax.Array, etc.
+                _ = a.shape
+                converted.append(a)
+            except AttributeError:
+                converted.append(_np.asarray(a))
+    if not converted:
+        return _np
+    try:
+        return array_namespace(*converted)
+    except TypeError:
+        return _np
+
+
+def to_float64(x: Any, xp):
+    """Cast *x* to float64 in namespace *xp*, preserving device."""
+    return xp.asarray(x, dtype=xp.float64)
+
+
+def broadcast_arrays(*args, xp):
+    """Broadcast all arrays to a common shape using *xp*."""
+    import numpy as np  # used only for shape computation
+    shapes = [xp.asarray(a).shape for a in args]
+    try:
+        out_shape = np.broadcast_shapes(*shapes)
+    except AttributeError:  # numpy < 1.20
+        out_shape = np.broadcast(*[np.empty(s) for s in shapes]).shape
+    return tuple(xp.broadcast_to(xp.asarray(a, dtype=xp.float64), out_shape) for a in args)
+
+
+# ---------------------------------------------------------------------------
+# Parallel chunking for NumPy path
+# ---------------------------------------------------------------------------
+_PARALLEL_THRESHOLD = 50_000
+
+
+def _n_workers() -> int:
+    return os.cpu_count() or 1
+
+
+def parallel_apply(fn, *arrays, threshold: int = _PARALLEL_THRESHOLD):
+    """Run *fn* across chunks if the input is large enough to benefit.
+
+    Falls back to serial when the array is small or only 1 CPU is available.
+    *fn* must accept flat numpy arrays and return a tuple of flat arrays.
+    """
+    import numpy as np
+    N = arrays[0].size
+    n = _n_workers()
+    if n <= 1 or N < threshold:
+        return fn(*arrays)
+    orig_shape = arrays[0].shape
+    flat = [a.ravel() for a in arrays]
+    chunk = math.ceil(N / n)
+    slices = [slice(i * chunk, min((i + 1) * chunk, N)) for i in range(n)]
+    chunks = [[f[s] for f in flat] for s in slices]
+    with ProcessPoolExecutor(max_workers=n) as pool:
+        results = list(pool.map(lambda c: fn(*c), chunks))
+    # results is a list of tuples (or single arrays); re-assemble
+    if isinstance(results[0], tuple):
+        return tuple(np.concatenate([r[i] for r in results]).reshape(orig_shape)
+                     for i in range(len(results[0])))
+    return np.concatenate(results).reshape(orig_shape)

elliptic/_xputils.py

@@ -0,0 +1,13 @@
+"""Array-namespace detection helper shared across all modules."""
+from __future__ import annotations
+
+from array_api_compat import array_namespace, is_array_api_obj
+import numpy as np
+
+
+def get_xp(*args):
+    """Return the array namespace for *args*, defaulting to numpy for plain scalars."""
+    api_objs = [a for a in args if is_array_api_obj(a)]
+    if api_objs:
+        return array_namespace(*api_objs)
+    return np

elliptic/agm.py

@@ -0,0 +1,19 @@
+"""Arithmetic-geometric mean — native on any array backend."""
+from __future__ import annotations
+from ._xputils import get_xp
+
+
+def agm(a0, b0):
+    """Arithmetic-geometric mean of *a0* and *b0*.
+
+    Iterates  a_{n+1} = (a_n + b_n)/2,  b_{n+1} = sqrt(a_n * b_n)
+    for 25 fixed steps (safe for float64).  Runs natively on NumPy,
+    PyTorch CUDA, and JAX.
+    """
+    xp = get_xp(a0, b0)
+    a = xp.asarray(a0, dtype=xp.float64)
+    b = xp.asarray(b0, dtype=xp.float64)
+    a, b = xp.broadcast_arrays(a, b)
+    for _ in range(25):
+        a, b = 0.5 * (a + b), xp.sqrt(a * b)
+    return a

elliptic/applications.py

@@ -0,0 +1,61 @@
+"""Application-level helpers built on top of the core elliptic functions."""
+from __future__ import annotations
+import numpy as np
+from array_api_compat import array_namespace
+from .elliptic12 import elliptic12
+
+
+def arclength_ellipse(a, b, theta0=0.0, theta1=None):
+    """Arc length of an ellipse from angle theta0 to theta1.
+
+    The ellipse is parameterised as  x = a cos t,  y = b sin t.
+    Angle t is measured from the positive a-axis (semi-major or semi-minor).
+
+    Parameters
+    ----------
+    a : float
+        First semi-axis.
+    b : float
+        Second semi-axis.
+    theta0 : float, optional
+        Start angle in radians. Default 0.
+    theta1 : float, optional
+        End angle in radians. Default 2π (full perimeter).
+
+    Returns
+    -------
+    arc : float
+        Arc length.
+
+    Examples
+    --------
+    Full perimeter of ellipse with a=5, b=10 (matches Mathematica):
+
+    >>> arclength_ellipse(5, 10)  # doctest: +ELLIPSIS
+    48.4422...
+
+    Notes
+    -----
+    For a circle (a == b) the formula reduces to a*(theta1 - theta0).
+    When b > a the standard formula is used:  b * E(theta1|1-(a/b)^2).
+    When a > b the complement formula applies: a * E(π/2-theta|1-(b/a)^2).
+    """
+    if theta1 is None:
+        theta1 = 2.0 * np.pi
+
+    a = float(a); b = float(b)
+    theta0 = float(theta0); theta1 = float(theta1)
+
+    if a == b:
+        return a * abs(theta1 - theta0)
+
+    if b > a:
+        m = 1.0 - (a / b) ** 2
+        _, E1, _ = elliptic12(np.asarray(theta1), np.asarray(m))
+        _, E0, _ = elliptic12(np.asarray(theta0), np.asarray(m))
+        return float(b * (float(E1) - float(E0)))
+    else:  # a > b
+        m = 1.0 - (b / a) ** 2
+        _, E1, _ = elliptic12(np.asarray(np.pi / 2.0 - theta1), np.asarray(m))
+        _, E0, _ = elliptic12(np.asarray(np.pi / 2.0 - theta0), np.asarray(m))
+        return float(a * (float(E0) - float(E1)))

elliptic/bulirsch.py

@@ -0,0 +1,70 @@
+"""Bulirsch's generalised complete elliptic integral and special cases.
+
+    cel(kc, p, a, b) = integral_0^inf (a + b t^2) / ((1 + p t^2) sqrt((1+t^2)(1+kc^2 t^2))) dt
+
+Special cases:
+    K(m)   = cel(sqrt(1-m), 1, 1, 1)
+    E(m)   = cel(sqrt(1-m), 1, 1, 1-m)
+    B(m)   = cel(sqrt(1-m), 1, 1, 0)
+    D(m)   = cel(sqrt(1-m), 1, 0, 1)
+    Pi(n|m) = cel(sqrt(1-m), 1-n, 1, 1)
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+
+from ._xputils import get_xp
+from .ellipticBD import _bd_xp
+from .elliptic12 import _elliptic12_xp
+from .carlson import _rj_xp
+
+
+def cel(kc, p, a, b):
+    """Bulirsch generalised complete elliptic integral."""
+    xp = get_xp(kc, p, a, b)
+    kc = xp.asarray(kc, dtype=xp.float64)
+    p  = xp.asarray(p,  dtype=xp.float64)
+    a  = xp.asarray(a,  dtype=xp.float64)
+    b  = xp.asarray(b,  dtype=xp.float64)
+    kc, p, a, b = xp.broadcast_arrays(kc, p, a, b)
+    return _cel_xp(xp, kc, p, a, b)
+
+
+def _cel_xp(xp, kc, p, a, b):
+    m    = 1.0 - kc * kc
+    phi  = xp.full_like(m, math.pi * 0.5)
+    K, _, _ = _elliptic12_xp(xp, phi, m)
+    B, D, _ = _bd_xp(xp, m)
+
+    # p ≈ 1 branch: C = a*B + b*D
+    C_p1 = a * B + b * D
+
+    # p ≠ 1 branch: C = a*K + (b - a*p)*(Pi - K)/(1-p)
+    n_val  = 1.0 - p
+    mc     = 1.0 - m
+    n_safe = xp.where(xp.abs(n_val) < 1e-14, xp.ones_like(n_val), n_val)
+    RJ     = _rj_xp(xp, xp.zeros_like(m), mc, xp.ones_like(m), p)
+    J_n    = RJ / 3.0
+    Pi_n   = K + n_val * J_n
+    C_pn   = a * K + (b - a * p) * (Pi_n - K) / n_safe
+
+    C = xp.where(xp.abs(p - 1.0) < 1e-12, C_p1, C_pn)
+    C = xp.where(kc < 0.0, xp.full_like(C, math.nan), C)
+    C = xp.where(p <= 0.0, xp.full_like(C, math.inf), C)
+    return C
+
+
+def cel1(kc):
+    """K(m) via Bulirsch: cel(kc, 1, 1, 1) where m = 1 - kc^2."""
+    return cel(kc, 1.0, 1.0, 1.0)
+
+
+def cel2(kc, a, b):
+    """Bulirsch cel2(kc, a, b) = cel(kc, 1, a, b)."""
+    return cel(kc, 1.0, a, b)
+
+
+def cel3(kc, p):
+    """Pi(n|m) via Bulirsch: cel(kc, p, 1, 1) where n = 1-p, m = 1-kc^2."""
+    return cel(kc, p, 1.0, 1.0)

elliptic/carlson.py

@@ -0,0 +1,186 @@
+"""Carlson symmetric elliptic integrals RF, RD, RJ, RC.
+
+All use Carlson's duplication algorithm with fixed iteration counts
+(20 for RF, 30 for RD/RJ) so they are JAX-traceable and run natively on
+any array backend (NumPy, PyTorch CUDA, JAX).
+
+References
+----------
+NIST DLMF §19.36 — https://dlmf.nist.gov/19.36
+B.C. Carlson, Numer. Algorithms 10 (1995), 13–26.
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+
+from ._xputils import get_xp
+
+
+# ---------------------------------------------------------------------------
+# RC — degenerate RF(x, y, y)  (closed-form)
+# ---------------------------------------------------------------------------
+
+def carlsonRC(x, y):
+    """Carlson RC(x, y) = RF(x, y, y).  Closed-form (DLMF 19.2.17)."""
+    xp = get_xp(x, y)
+    x = xp.asarray(x, dtype=xp.float64)
+    y = xp.asarray(y, dtype=xp.float64)
+    x, y = xp.broadcast_arrays(x, y)
+    return _rc_xp(xp, x, y)
+
+
+def _rc_xp(xp, x, y):
+    EPS = 1e-300
+    diff = y - x
+
+    # safe arguments for each branch (avoid div-by-zero when not selected)
+    x_safe   = xp.where(x > EPS, x, xp.full_like(x, 1.0))
+    yd_safe  = xp.where(diff > EPS, diff, xp.full_like(diff, 1.0))
+    yd_safe2 = xp.where(-diff > EPS, -diff, xp.full_like(diff, 1.0))
+    y_safe   = xp.where(y > EPS, y, xp.full_like(y, 1.0))
+
+    rc_gt  = xp.arctan(xp.sqrt(xp.clip(diff / x_safe, 0.0, None))) / xp.sqrt(yd_safe)
+    rc_lt  = xp.arctanh(xp.sqrt(xp.clip(-diff / x_safe, 0.0, None))) / xp.sqrt(yd_safe2)
+    rc_eq  = 1.0 / xp.sqrt(x_safe)
+    rc_x0  = (math.pi * 0.5) / xp.sqrt(y_safe)
+
+    TOL = 1e-14
+    out = xp.where(diff > TOL, rc_gt, xp.where(diff < -TOL, rc_lt, rc_eq))
+    out = xp.where(x < EPS, rc_x0, out)
+    out = xp.where(y < EPS, xp.full_like(out, math.inf), out)
+    return out
+
+
+# keep old numpy version for any legacy callers
+def _rc_numpy(x: np.ndarray, y: np.ndarray) -> np.ndarray:
+    return _rc_xp(np, x, y)
+
+
+# ---------------------------------------------------------------------------
+# RF — symmetric first kind
+# ---------------------------------------------------------------------------
+
+def carlsonRF(x, y, z):
+    """Carlson RF(x, y, z) — symmetric elliptic integral of the first kind.
+
+    F(phi|m) = sin(phi) * RF(cos²phi, 1 - m sin²phi, 1).
+    """
+    xp = get_xp(x, y, z)
+    x = xp.asarray(x, dtype=xp.float64)
+    y = xp.asarray(y, dtype=xp.float64)
+    z = xp.asarray(z, dtype=xp.float64)
+    x, y, z = xp.broadcast_arrays(x, y, z)
+    return _rf_xp(xp, x, y, z)
+
+
+def _rf_xp(xp, x, y, z):
+    for _ in range(20):
+        lam = xp.sqrt(x * y) + xp.sqrt(y * z) + xp.sqrt(z * x)
+        x = (x + lam) * 0.25
+        y = (y + lam) * 0.25
+        z = (z + lam) * 0.25
+    A  = (x + y + z) / 3.0
+    X  = (A - x) / A
+    Y  = (A - y) / A
+    Z  = -X - Y
+    E2 = X * Y - Z * Z
+    E3 = X * Y * Z
+    return A ** (-0.5) * (1.0 - E2/10.0 + E3/14.0 + E2**2/24.0 - 3.0*E2*E3/44.0)
+
+
+def _rf_numpy(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
+    return _rf_xp(np, x, y, z)
+
+
+# ---------------------------------------------------------------------------
+# RD — symmetric second kind
+# ---------------------------------------------------------------------------
+
+def carlsonRD(x, y, z):
+    """Carlson RD(x, y, z) — symmetric elliptic integral of the second kind.
+
+    D(phi|m) = (sin³phi/3) * RD(cos²phi, 1 - m sin²phi, 1).
+    """
+    xp = get_xp(x, y, z)
+    x = xp.asarray(x, dtype=xp.float64)
+    y = xp.asarray(y, dtype=xp.float64)
+    z = xp.asarray(z, dtype=xp.float64)
+    x, y, z = xp.broadcast_arrays(x, y, z)
+    return _rd_xp(xp, x, y, z)
+
+
+def _rd_xp(xp, x, y, z):
+    S   = xp.zeros_like(x)
+    fac = xp.ones_like(x)
+    for _ in range(30):
+        lam = xp.sqrt(x * y) + xp.sqrt(y * z) + xp.sqrt(z * x)
+        S   = S + fac / (xp.sqrt(z) * (z + lam))
+        fac = fac * 0.25
+        x = (x + lam) * 0.25
+        y = (y + lam) * 0.25
+        z = (z + lam) * 0.25
+    A  = (x + y + 3.0 * z) / 5.0
+    X  = (A - x) / A
+    Y  = (A - y) / A
+    Z  = -(X + Y) / 3.0
+    E2 = X * Y - 6.0 * Z**2
+    E3 = (3.0 * X * Y - 8.0 * Z**2) * Z
+    E4 = 3.0 * (X * Y - Z**2) * Z**2
+    E5 = X * Y * Z**3
+    poly = (1.0 - 3.0*E2/14.0 + E3/6.0 + 9.0*E2**2/88.0
+            - 3.0*E4/22.0 - 9.0*E2*E3/52.0 + 3.0*E5/26.0)
+    return 3.0 * S + fac * A**(-1.5) * poly
+
+
+def _rd_numpy(x: np.ndarray, y: np.ndarray, z: np.ndarray) -> np.ndarray:
+    return _rd_xp(np, x, y, z)
+
+
+# ---------------------------------------------------------------------------
+# RJ — symmetric third kind
+# ---------------------------------------------------------------------------
+
+def carlsonRJ(x, y, z, p):
+    """Carlson RJ(x, y, z, p) — symmetric elliptic integral of the third kind.
+
+    J(phi,n|m) = (sin³phi/3) * RJ(cos²phi, 1-m sin²phi, 1, 1-n sin²phi).
+    """
+    xp = get_xp(x, y, z, p)
+    x = xp.asarray(x, dtype=xp.float64)
+    y = xp.asarray(y, dtype=xp.float64)
+    z = xp.asarray(z, dtype=xp.float64)
+    p = xp.asarray(p, dtype=xp.float64)
+    x, y, z, p = xp.broadcast_arrays(x, y, z, p)
+    return _rj_xp(xp, x, y, z, p)
+
+
+def _rj_xp(xp, x, y, z, p):
+    S   = xp.zeros_like(x)
+    fac = xp.ones_like(x)
+    for _ in range(30):
+        lam   = xp.sqrt(x * y) + xp.sqrt(y * z) + xp.sqrt(z * x)
+        alpha = (p * (xp.sqrt(x) + xp.sqrt(y) + xp.sqrt(z)) + xp.sqrt(x * y * z)) ** 2
+        beta  = p * (p + lam) ** 2
+        S     = S + fac * _rc_xp(xp, alpha, beta)
+        fac   = fac * 0.25
+        x = (x + lam) * 0.25
+        y = (y + lam) * 0.25
+        z = (z + lam) * 0.25
+        p = (p + lam) * 0.25
+    A  = (x + y + z + 2.0 * p) / 5.0
+    X  = (A - x) / A
+    Y  = (A - y) / A
+    Z  = (A - z) / A
+    P  = -(X + Y + Z) / 2.0
+    E2 = X*Y + X*Z + Y*Z - 3.0*P**2
+    E3 = X*Y*Z + 2.0*E2*P + 3.0*P**3
+    E4 = (2.0*X*Y*Z + E2*P + 3.0*P**3) * P
+    E5 = X*Y*Z * P**2
+    poly = (1.0 - 3.0*E2/14.0 + E3/6.0 + 9.0*E2**2/88.0
+            - 3.0*E4/22.0 - 9.0*E2*E3/52.0 + 3.0*E5/26.0)
+    return 3.0 * S + fac * A**(-1.5) * poly
+
+
+def _rj_numpy(x: np.ndarray, y: np.ndarray, z: np.ndarray, p: np.ndarray) -> np.ndarray:
+    return _rj_xp(np, x, y, z, p)