Trait SpecializedSpecialMath 

pub trait SpecializedSpecialMath<E>: SpecializedTranscendentalMath<E> {
    type ExpIntDetails: ExpIntDetails<E, Self>;

    const LAGUERRE_PRODUCT_SEED_CAP: i32 = 0;

    // Required methods
    fn erf<P: Policy>(self) -> Self;
    fn tgamma<P: Policy>(self) -> Self;
    fn lgamma<P: Policy>(self) -> Self;
    fn digamma<P: Policy>(self) -> Self;
    fn trigamma<P: Policy>(self) -> Self;
    fn polygamma<P: Policy>(self, n: u32) -> Self;
    fn beta<P: Policy>(a: Self, b: Self) -> Self;
    fn lambert_w<P: Policy>(self) -> (Self, Self);

    // Provided methods
    fn exp_two_sum(a: Self, b: Self) -> (Self, Self) { ... }
    fn erfc<P: Policy>(self) -> Self { ... }
    fn erfcx<P: Policy>(self) -> Self { ... }
    fn expint_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn expint_primal_n<P: Policy, const N: usize>(self) -> (Self, Self) { ... }
    fn expint<P: Policy>(self, n: u32) -> Self { ... }
    fn expint_primal<P: Policy>(self, n: u32) -> (Self, Self) { ... }
    fn logistic_sigmoid<P: Policy>(self) -> Self { ... }
    fn softplus<P: Policy>(self, k: Self, rcp_k: Self) -> Self { ... }
    fn zetac<P: Policy>(self) -> Self { ... }
    fn zeta<P: Policy>(self) -> Self { ... }
    fn polylog<P: Policy>(
        self,
        order: PolylogOrder<E, <<Self as GenericVector>::Signed as GenericVector>::Element>,
    ) -> Self { ... }
    fn zeta_with_deriv<P: Policy, const ZETAC: bool>(self) -> (Self, Self) { ... }
    fn bessel_i<P: Policy, const N: i32>(self) -> Self { ... }
    fn bessel_i_scaled<P: Policy, const N: i32>(self) -> Self { ... }
    fn bessel_k<P: Policy, const N: i32>(self) -> Self { ... }
    fn bessel_k_scaled<P: Policy, const N: i32>(self) -> Self { ... }
    fn bessel_j<P: Policy, const N: i32>(self) -> Self { ... }
    fn bessel_y<P: Policy, const N: i32>(self) -> Self { ... }
    fn bessel_i_with_deriv<P: Policy, const N: i32, const SCALED: bool>(
        self,
    ) -> (Self, Self) { ... }
    fn bessel_k_with_deriv<P: Policy, const N: i32, const SCALED: bool>(
        self,
    ) -> (Self, Self) { ... }
    fn bessel_j_with_deriv<P: Policy, const N: i32>(self) -> (Self, Self) { ... }
    fn bessel_y_with_deriv<P: Policy, const N: i32>(self) -> (Self, Self) { ... }
    fn bessel_iv<P: Policy, const SCALED: bool>(
        self,
        _order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn bessel_kv<P: Policy, const SCALED: bool>(
        self,
        _order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn bessel_jv<P: Policy>(
        self,
        _order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn bessel_yv<P: Policy>(
        self,
        _order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn sph_bessel_j_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn sph_bessel_y_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn sph_bessel_i_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn sph_bessel_i_scaled_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn sph_bessel_k_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn sph_bessel_k_scaled_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn sph_bessel_j_with_deriv_n<P: Policy, const N: usize>(
        self,
    ) -> (Self, Self) { ... }
    fn sph_bessel_y_with_deriv_n<P: Policy, const N: usize>(
        self,
    ) -> (Self, Self) { ... }
    fn sph_bessel_i_with_deriv_n<P: Policy, const N: usize, const SCALED: bool>(
        self,
    ) -> (Self, Self) { ... }
    fn sph_bessel_k_with_deriv_n<P: Policy, const N: usize, const SCALED: bool>(
        self,
    ) -> (Self, Self) { ... }
    fn sph_bessel_j<P: Policy>(self, n: u32) -> Self { ... }
    fn sph_bessel_y<P: Policy>(self, n: u32) -> Self { ... }
    fn sph_bessel_i<P: Policy>(self, n: u32) -> Self { ... }
    fn sph_bessel_i_scaled<P: Policy>(self, n: u32) -> Self { ... }
    fn sph_bessel_k<P: Policy>(self, n: u32) -> Self { ... }
    fn sph_bessel_k_scaled<P: Policy>(self, n: u32) -> Self { ... }
    fn sph_bessel_j_with_deriv<P: Policy>(self, n: u32) -> (Self, Self) { ... }
    fn sph_bessel_y_with_deriv<P: Policy>(self, n: u32) -> (Self, Self) { ... }
    fn sph_bessel_i_with_deriv<P: Policy, const SCALED: bool>(
        self,
        n: u32,
    ) -> (Self, Self) { ... }
    fn sph_bessel_k_with_deriv<P: Policy, const SCALED: bool>(
        self,
        n: u32,
    ) -> (Self, Self) { ... }
    fn bessel_n<P: Policy, F: BesselFamily, const N: i32>(self) -> Self { ... }
    fn bessel<P: Policy, F: BesselFamily>(
        self,
        order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn sph_bessel_n<P: Policy, F: BesselFamily, const N: usize>(self) -> Self { ... }
    fn sph_bessel<P: Policy, F: BesselFamily>(self, n: u32) -> Self { ... }
    fn airy<P: Policy, W: AiryFn>(self) -> Self { ... }
    fn airy_all<P: Policy, const SCALED: bool>(self) -> (Self, Self, Self, Self) { ... }
    fn bessel_jv_scaled<P: Policy>(
        self,
        order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn bessel_yv_scaled<P: Policy>(
        self,
        order: BesselOrder<Self, Self::Signed>,
    ) -> Self { ... }
    fn airy_tuple<P: Policy>(self) -> (Self, Self, Self, Self) { ... }
    fn airy_tuple_scaled<P: Policy>(self) -> (Self, Self, Self, Self) { ... }
    fn airy_ai<P: Policy>(self) -> Self { ... }
    fn airy_ai_scaled<P: Policy>(self) -> Self { ... }
    fn airy_bi<P: Policy>(self) -> Self { ... }
    fn airy_bi_scaled<P: Policy>(self) -> Self { ... }
    fn airy_ai_prime<P: Policy>(self) -> Self { ... }
    fn airy_ai_prime_scaled<P: Policy>(self) -> Self { ... }
    fn airy_bi_prime<P: Policy>(self) -> Self { ... }
    fn airy_bi_prime_scaled<P: Policy>(self) -> Self { ... }
    fn hermite_n<P: Policy, const N: usize>(x: Self) -> Self { ... }
    fn hermitev<P: Policy>(x: Self, n: Self::Unsigned) -> Self { ... }
    fn hermite<P: Policy>(self, n: u32) -> Self { ... }
    fn hermite_function_n<P: Policy, const N: usize>(x: Self) -> Self { ... }
    fn hermite_function<P: Policy>(x: Self, n: u32) -> Self { ... }
    fn hermite_function_series_n<P: Policy, const N: usize>(
        self,
        coeffs: &[Self::Element; N],
    ) -> Self { ... }
    fn hermite_function_series<P: Policy>(
        self,
        coeffs: &[Self::Element],
    ) -> Self { ... }
    fn laguerre_n<P: Policy, const N: usize>(x: Self, alpha: Self) -> Self { ... }
    fn laguerrev<P: Policy>(x: Self, alpha: Self, n: Self::Unsigned) -> Self { ... }
    fn laguerre<P: Policy>(self, alpha: Self, n: u32) -> Self { ... }
    fn laguerre_function_n<P: Policy, const N: usize>(
        x: Self,
        alpha: Self,
    ) -> Self { ... }
    fn laguerre_function<P: Policy>(x: Self, alpha: Self, n: u32) -> Self { ... }
    fn laguerre_function_i_n<P: Policy, const N: usize>(
        x: Self,
        alpha: i32,
    ) -> Self { ... }
    fn laguerre_function_i<P: Policy>(x: Self, alpha: i32, n: u32) -> Self { ... }
    fn poisson_pmf<P: Policy>(self, lambda: Self) -> Self { ... }
    fn poisson_log_pmf<P: Policy>(self, lambda: Self) -> Self { ... }
    fn laguerre_function_series_n<P: Policy, const N: usize>(
        self,
        alpha: Self,
        coeffs: &[Self::Element; N],
    ) -> Self { ... }
    fn laguerre_function_series_i_n<P: Policy, const N: usize>(
        self,
        alpha: i32,
        coeffs: &[Self::Element; N],
    ) -> Self { ... }
    fn laguerre_function_series<P: Policy>(
        self,
        alpha: Self,
        coeffs: &[Self::Element],
    ) -> Self { ... }
    fn laguerre_function_series_i<P: Policy>(
        self,
        alpha: i32,
        coeffs: &[Self::Element],
    ) -> Self { ... }
    fn chebyshev<P: Policy, const K: usize>(
        self,
        coeffs: &[Self::Element],
    ) -> Self { ... }
    fn chebyshev_n<P: Policy, const K: usize, const N: usize>(
        self,
        coeffs: &[Self::Element; N],
    ) -> Self { ... }
    fn jacobi<P: Policy>(
        x: Self,
        alpha: Self,
        beta: Self,
        n: u32,
        m: u32,
    ) -> Self { ... }
    fn gaussian<P: Policy>(x: Self, a: Self, c: Self) -> Self { ... }
    fn lbeta<P: Policy>(a: Self, b: Self) -> Self { ... }
    fn logit<P: Policy>(self) -> Self { ... }
    fn logit_1m<P: Policy>(self) -> Self { ... }
    fn planck<P: Policy>(self) -> Self { ... }
    fn legendre0<P: Policy, const N: u32>(x: Self, n: u32) -> Self { ... }
    fn legendre<P: Policy>(x: Self, n: u32, m: u32) -> Self { ... }
    fn legendre_series_n<P: Policy, const N: usize>(
        self,
        coeffs: &[Self::Element; N],
    ) -> Self { ... }
    fn legendre_series<P: Policy>(self, coeffs: &[Self::Element]) -> Self { ... }
    fn zernike_r<P: Policy>(rho: Self, n: u32, m: u32) -> Self { ... }
    fn zernike<P: Policy, const NORM: u8>(
        rho: Self,
        theta: Self,
        n: u32,
        m: i32,
    ) -> Self { ... }
    fn zernike_basis<P: Policy, const L: usize, const NORM: u8, const N: usize>(
        x: Self,
        y: Self,
        out: &mut [Self; N],
    ) { ... }
    fn phi_n<P: Policy, const N: usize>(self) -> Self { ... }
    fn phi<P: Policy>(self, n: u32) -> Self { ... }
}

Provided Associated Constants

const LAGUERRE_PRODUCT_SEED_CAP: i32 = 0

Largest integer weight for which laguerre_function_i seeds by the direct product x^{alpha/2} / sqrt(alpha!) (a scalar factorial, powi, at most one sqrt) instead of the general exp(alpha/2 ln x - lgamma(alpha+1)/2). 0 disables it.

The bound is per arithmetic because it is set by the exponent range: alpha! must stay finite, and x^{alpha/2} must stay finite wherever e^{-x/4} is still non-zero (so inf * 0 cannot arise). Those give 170 / 29 for binary64 / binary32; see generic::laguerre::product_seed. The default is the safe “never”.

It lives on the trait rather than as a const generic on the kernel so that the composites can inherit it: Dual<V, N> is one blanket impl with no binary32/64 split to hang a literal on, and forwarding V’s value is the only way it keeps the product seed at all.

Required Associated Types

type ExpIntDetails: ExpIntDetails<E, Self>

Per-arithmetic details of the expint kernel. Almost always Self, with an empty ExpIntDetails impl taking every default.

Required Methods

fn erf<P: Policy>(self) -> Self

fn tgamma<P: Policy>(self) -> Self

fn lgamma<P: Policy>(self) -> Self

fn digamma<P: Policy>(self) -> Self

fn trigamma<P: Policy>(self) -> Self

The trigamma function psi_1(x) = d/dx psi(x), the second derivative of ln Gamma.

Public on SpecialMath since 2026-08-29. It was deliberately absent while the Gamma-derivative family was open-ended (a public trigamma obliged Dual to produce psi_2, which needed psi_3, and so on). polygamma’s runtime order closed that ladder, and every implementor of this trait already carried a working trigamma, so publishing became a pure decl move.

Not defined at zero or the negative integers.

fn polygamma<P: Policy>(self, n: u32) -> Self

The polygamma function $\psi_n(x)$, the n-th derivative of digamma.

The order is a runtime scalar, uniform across lanes, deliberately: runtime n is what closes the family under differentiation ($\psi_n' = \psi_{n+1}$ is just n + 1), where a const-generic order would recurse without bound in Dual’s chain rule. It costs SIMD nothing, since every order-dependent coefficient is scalar math splatted once.

On this trait (rather than the real-only one) since 2026-08-29 so that complex vectors carry it too. The complex implementation reflects at Re z < 1/2 and shares the real kernel’s series structure in complex arithmetic.

fn beta<P: Policy>(a: Self, b: Self) -> Self

fn lambert_w<P: Policy>(self) -> (Self, Self)

Provided Methods

fn exp_two_sum(a: Self, b: Self) -> (Self, Self)

TwoSum for exponent assembly: (a + b, the rounding it discarded). Internal to this trait; it is a lowering detail of the Poisson exponent.

The default returns a zero residual on purpose. A TwoSum spelled with +/- is only error-free while those are strict, and on the scalar backend under algebraic-scalar they are not: LLVM folds the residual to zero. ps.rs/pd.rs override this with the strict FloatVectorWithBits::two_sum, and Dual delegates componentwise to its inner type. Do not “optimize” the default by spelling the six adds here; it passes every test on every SIMD backend and is silently wrong on exactly one configuration.

fn erfc<P: Policy>(self) -> Self

fn erfcx<P: Policy>(self) -> Self

$e^{x^2}\operatorname{erfc}(x)$, which does not underflow where erfc does.

This default is the direct form, whose failure is what the function exists to fix: $e^{x^2}$ overflows just where erfc underflows, so it is useful only for $|x|$ under about 26.6 (binary64) or 9.3 (binary32). The real backends override it with the imaginary-axis Weideman evaluation, which has no such limit (see generic::erfcx). Element types without a Weideman table (Compensated) take this and inherit its range.

fn expint_n<P: Policy, const N: usize>(self) -> Self

Computes the exponential integral E_N(x) for integer order N.

fn expint_primal_n<P: Policy, const N: usize>(self) -> (Self, Self)

Computes $E_N(x)$ together with the adjacent lower order $E_{N-1}(x)$.

Differentiating the integral definition under the integral sign gives $E_N'(x) = -E_{N-1}(x)$, so the second element is the derivative up to sign. The order recurrence already walks E_1 -> E_N, which makes E_{N-1} simply the previous iterate: the pair costs no more than the value alone. thermite-dual uses this to take the (guarded) real path for both parts rather than running this entire routine in dual arithmetic.

Uses the power series for x < 1 and the Stieltjes continued fraction for x >= 1, computed in parallel across SIMD lanes and blended at the end. For N > 1, applies the recurrence $E_{n+1}(x) = (e^{-x} - x \cdot E_n(x)) / n$.

fn expint<P: Policy>(self, n: u32) -> Self

The runtime-order twin of expint_n.

fn expint_primal<P: Policy>(self, n: u32) -> (Self, Self)

The runtime-order twin of expint_primal_n: the same E_1 core, the same recurrence with the order as a value.

fn logistic_sigmoid<P: Policy>(self) -> Self

fn softplus<P: Policy>(self, k: Self, rcp_k: Self) -> Self

fn zetac<P: Policy>(self) -> Self

Compensated keeps the default: the Euler-Maclaurin coefficients are tabulated to f64, so a double-double built from them would carry 53 real bits and noise, the same reason it has no GammaPrimalTables impl. Dual overrides it through zeta_with_deriv.

fn zeta<P: Policy>(self) -> Self

zeta(s), as 1 + zetac(s). Defaulted for the same reason as zetac.

fn polylog<P: Policy>( self, order: PolylogOrder<E, <<Self as GenericVector>::Signed as GenericVector>::Element>, ) -> Self

Li_s(z) at a scalar order. Defaulted for the same reason as zetac: the coefficient precompute is f64, so a double-double has nothing to reach for. Dual overrides it through the order-lowering identity Li_s' = Li_{s-1}/z.

fn zeta_with_deriv<P: Policy, const ZETAC: bool>(self) -> (Self, Self)

(zeta(s), zeta'(s)), or (zeta(s) - 1, zeta'(s)) when ZETAC is set: the two functions differ by a constant, so one derivative serves both.

This exists because zeta' is a second kernel rather than a chain rule over zeta: zeta'(s) = -sum ln(n) n^-s, which has no expression in terms of zeta itself. It shares every transcendental with the value, so computing both together is far cheaper than computing them apart, which is what lets Dual differentiate without running the correction ladder in dual arithmetic.

fn bessel_i<P: Policy, const N: i32>(self) -> Self

I_N(x), or e^{-|x|} I_N(x) when SCALED: the modified Bessel function of the first kind at compile-time integer order.

One method serves both the scaled and unscaled public entry points because they are not built from each other: each table region is natively one or the other, so the SCALED flag moves which arm pays for an exponential rather than adding one.

Defaulted rather than required: the coefficient tables are element-specific, so a generic composite has nothing to reach for.

fn bessel_i_scaled<P: Policy, const N: i32>(self) -> Self

e^{-|x|} I_N(x). Not a wrapper over bessel_i: above the series threshold the coefficient tables are the scaled value, so this form skips the exponential the unscaled one pays for, and stays finite where I_N overflows.

fn bessel_k<P: Policy, const N: i32>(self) -> Self

K_N(x), the modified Bessel function of the second kind at compile-time integer order. Defaulted for the same reason as bessel_i.

fn bessel_k_scaled<P: Policy, const N: i32>(self) -> Self

e^{x} K_N(x). Not a wrapper: above the series threshold the tables are natively the scaled quantity, so this form skips the exponential the unscaled one pays for, and stays in range where K_N has decayed to zero.

fn bessel_j<P: Policy, const N: i32>(self) -> Self

J_N(x), the oscillatory Bessel function of the first kind. Orders 0 and 1 only for now. Higher orders want a recurrence that is not written yet.

fn bessel_y<P: Policy, const N: i32>(self) -> Self

Y_N(x), the oscillatory Bessel function of the second kind.

fn bessel_i_with_deriv<P: Policy, const N: i32, const SCALED: bool>( self, ) -> (Self, Self)

(I_N(x), d/dx I_N(x)), or the scaled pair when SCALED.

A second kernel rather than a chain rule, for the same reason zeta_with_deriv is: every derivative identity in this family reaches DOWN one order, I_N' = I_{N-1} - (N/x) I_N, so the value and the derivative share almost all of their work: the ratio recurrence produces I_{N-1} alongside I_N for free. It is also what lets Dual differentiate without running the recurrence in dual arithmetic.

That the identity reaches down and not up is the fact that unblocks this whole family: the textbook form J_N' = (J_{N-1} - J_{N+1})/2 needs an order ABOVE N, which is why bessel_j sat disabled for so long.

fn bessel_k_with_deriv<P: Policy, const N: i32, const SCALED: bool>( self, ) -> (Self, Self)

(K_N(x), d/dx K_N(x)). See bessel_i_with_deriv.

fn bessel_j_with_deriv<P: Policy, const N: i32>(self) -> (Self, Self)

(J_N(x), d/dx J_N(x)). See bessel_i_with_deriv.

fn bessel_y_with_deriv<P: Policy, const N: i32>(self) -> (Self, Self)

(Y_N(x), d/dx Y_N(x)). See bessel_i_with_deriv.

fn bessel_iv<P: Policy, const SCALED: bool>( self, _order: BesselOrder<Self, Self::Signed>, ) -> Self

I_n(x) with a per-lane order. See bessel_i.

fn bessel_kv<P: Policy, const SCALED: bool>( self, _order: BesselOrder<Self, Self::Signed>, ) -> Self

K_n(x) with a per-lane order. See bessel_k.

fn bessel_jv<P: Policy>(self, _order: BesselOrder<Self, Self::Signed>) -> Self

J_n(x) with a per-lane order. See bessel_j.

fn bessel_yv<P: Policy>(self, _order: BesselOrder<Self, Self::Signed>) -> Self

Y_n(x) with a per-lane order. See bessel_y.

fn sph_bessel_j_n<P: Policy, const N: usize>(self) -> Self

j_n(x), the spherical Bessel function of the first kind. See sph_bessel_j.

fn sph_bessel_y_n<P: Policy, const N: usize>(self) -> Self

y_n(x). See sph_bessel_y.

fn sph_bessel_i_n<P: Policy, const N: usize>(self) -> Self

i_n(x). See sph_bessel_i.

fn sph_bessel_i_scaled_n<P: Policy, const N: usize>(self) -> Self

e^{-x} i_n(x). See sph_bessel_i_scaled.

fn sph_bessel_k_n<P: Policy, const N: usize>(self) -> Self

k_n(x). See sph_bessel_k.

fn sph_bessel_k_scaled_n<P: Policy, const N: usize>(self) -> Self

e^{x} k_n(x). See sph_bessel_k_scaled.

fn sph_bessel_j_with_deriv_n<P: Policy, const N: usize>(self) -> (Self, Self)

(j_n(x), j_n'(x)), both from one walk.

The derivative identity reaches down one order, f_n' = f_{n-1} - ((n+1)/x) f_n, and the recurrence passes through n-1 regardless, so the pair costs no more than the value. Exists for Dual, on the same footing as bessel_j_with_deriv.

fn sph_bessel_y_with_deriv_n<P: Policy, const N: usize>(self) -> (Self, Self)

(y_n(x), y_n'(x)). See sph_bessel_j_with_deriv.

fn sph_bessel_i_with_deriv_n<P: Policy, const N: usize, const SCALED: bool>( self, ) -> (Self, Self)

(i_n(x), i_n'(x)), scaled by e^{-x} when SCALED, in which case the derivative is the scaled function’s own, d/dx(e^{-x} i_n) = e^{-x}(i_n' - i_n).

fn sph_bessel_k_with_deriv_n<P: Policy, const N: usize, const SCALED: bool>( self, ) -> (Self, Self)

(k_n(x), k_n'(x)), scaled by e^{x} when SCALED.

fn sph_bessel_j<P: Policy>(self, n: u32) -> Self

j_n(x) for a runtime order. See sph_bessel_j.

fn sph_bessel_y<P: Policy>(self, n: u32) -> Self

y_n(x) for a runtime order.

fn sph_bessel_i<P: Policy>(self, n: u32) -> Self

i_n(x) for a runtime order.

fn sph_bessel_i_scaled<P: Policy>(self, n: u32) -> Self

e^{-x} i_n(x) for a runtime order.

fn sph_bessel_k<P: Policy>(self, n: u32) -> Self

k_n(x) for a runtime order.

fn sph_bessel_k_scaled<P: Policy>(self, n: u32) -> Self

e^{x} k_n(x) for a runtime order.

fn sph_bessel_j_with_deriv<P: Policy>(self, n: u32) -> (Self, Self)

(j_n(x), j_n'(x)) for a runtime order. See sph_bessel_j_with_deriv_n.

fn sph_bessel_y_with_deriv<P: Policy>(self, n: u32) -> (Self, Self)

(y_n(x), y_n'(x)) for a runtime order.

fn sph_bessel_i_with_deriv<P: Policy, const SCALED: bool>( self, n: u32, ) -> (Self, Self)

(i_n(x), i_n'(x)) for a runtime order, scaled by e^{-x} when SCALED.

fn sph_bessel_k_with_deriv<P: Policy, const SCALED: bool>( self, n: u32, ) -> (Self, Self)

(k_n(x), k_n'(x)) for a runtime order, scaled by e^{x} when SCALED.

fn bessel_n<P: Policy, F: BesselFamily, const N: i32>(self) -> Self

bessel_n::<F, N>(): see BesselFamily.

fn bessel<P: Policy, F: BesselFamily>( self, order: BesselOrder<Self, Self::Signed>, ) -> Self

bessel::<F>(order): see BesselFamily.

fn sph_bessel_n<P: Policy, F: BesselFamily, const N: usize>(self) -> Self

sph_bessel_n::<F, N>().

fn sph_bessel<P: Policy, F: BesselFamily>(self, n: u32) -> Self

sph_bessel::<F>(n).

fn airy<P: Policy, W: AiryFn>(self) -> Self

airy::<W>(): see AiryFn.

fn airy_all<P: Policy, const SCALED: bool>(self) -> (Self, Self, Self, Self)

The four Airy values, scaled on the positive axis when SCALED.

fn bessel_jv_scaled<P: Policy>( self, order: BesselOrder<Self, Self::Signed>, ) -> Self

Scaled(J) at runtime order: e^{-|Im z|} J_nu(z), SciPy’s jve. The scale factor is 1 on the real axis, so the default is the unscaled value. Complex overrides.

fn bessel_yv_scaled<P: Policy>( self, order: BesselOrder<Self, Self::Signed>, ) -> Self

Scaled(Y) at runtime order, the Y twin of bessel_jv_scaled.

fn airy_tuple<P: Policy>(self) -> (Self, Self, Self, Self)

(Ai, Ai', Bi, Bi'). See airy.

The kernel needs the LogGamma1p and AiryZero tables keyed to a concrete element, which a generic E on this trait does not carry, the same bind the Bessel family is in. The ps/pd impls override this. A composite gets this until it supplies its own.

Worth overriding for a derivative-carrying composite, and unusually easy to: Airy satisfies $w'' = xw$, so every derivative past the first is a combination of the value and the first derivative, both of which this returns. Nothing needs to differentiate the Bessel machinery underneath.

fn airy_tuple_scaled<P: Policy>(self) -> (Self, Self, Self, Self)

(Ai, Ai', Bi, Bi') with the exponential factored out on the positive axis. Not a wrapper over airy: it is the form the kernel produces natively, and the unscaled one is the wrapper. See airy with a Scaled marker.

fn airy_ai<P: Policy>(self) -> Self

Ai(x) alone: a cheaper evaluation than airy, not a projection of it. See airy_ai.

fn airy_ai_scaled<P: Policy>(self) -> Self

e^zeta Ai(x) on the positive axis. See airy_ai_scaled.

fn airy_bi<P: Policy>(self) -> Self

Bi(x) alone. See airy_bi.

fn airy_bi_scaled<P: Policy>(self) -> Self

e^-zeta Bi(x) on the positive axis. See airy_bi_scaled.

fn airy_ai_prime<P: Policy>(self) -> Self

Ai'(x) alone. See airy_ai_prime.

fn airy_ai_prime_scaled<P: Policy>(self) -> Self

e^zeta Ai'(x) on the positive axis. See airy_ai_prime_scaled.

fn airy_bi_prime<P: Policy>(self) -> Self

Bi'(x) alone. See airy_bi_prime.

fn airy_bi_prime_scaled<P: Policy>(self) -> Self

e^-zeta Bi'(x) on the positive axis. See airy_bi_prime_scaled.

fn hermite_n<P: Policy, const N: usize>(x: Self) -> Self

fn hermitev<P: Policy>(x: Self, n: Self::Unsigned) -> Self

fn hermite<P: Policy>(self, n: u32) -> Self

A uniform runtime degree is hermitev with the degree splatted. Nothing cheaper is correct.

fn hermite_function_n<P: Policy, const N: usize>(x: Self) -> Self

fn hermite_function<P: Policy>(x: Self, n: u32) -> Self

fn hermite_function_series_n<P: Policy, const N: usize>( self, coeffs: &[Self::Element; N], ) -> Self

fn hermite_function_series<P: Policy>(self, coeffs: &[Self::Element]) -> Self

fn laguerre_n<P: Policy, const N: usize>(x: Self, alpha: Self) -> Self

fn laguerrev<P: Policy>(x: Self, alpha: Self, n: Self::Unsigned) -> Self

fn laguerre<P: Policy>(self, alpha: Self, n: u32) -> Self

A uniform runtime degree is laguerrev with the degree splatted.

fn laguerre_function_n<P: Policy, const N: usize>(x: Self, alpha: Self) -> Self

fn laguerre_function<P: Policy>(x: Self, alpha: Self, n: u32) -> Self

fn laguerre_function_i_n<P: Policy, const N: usize>(x: Self, alpha: i32) -> Self

fn laguerre_function_i<P: Policy>(x: Self, alpha: i32, n: u32) -> Self

fn poisson_pmf<P: Policy>(self, lambda: Self) -> Self

fn poisson_log_pmf<P: Policy>(self, lambda: Self) -> Self

fn laguerre_function_series_n<P: Policy, const N: usize>( self, alpha: Self, coeffs: &[Self::Element; N], ) -> Self

fn laguerre_function_series_i_n<P: Policy, const N: usize>( self, alpha: i32, coeffs: &[Self::Element; N], ) -> Self

fn laguerre_function_series<P: Policy>( self, alpha: Self, coeffs: &[Self::Element], ) -> Self

fn laguerre_function_series_i<P: Policy>( self, alpha: i32, coeffs: &[Self::Element], ) -> Self

fn chebyshev<P: Policy, const K: usize>(self, coeffs: &[Self::Element]) -> Self

fn chebyshev_n<P: Policy, const K: usize, const N: usize>( self, coeffs: &[Self::Element; N], ) -> Self

fn jacobi<P: Policy>(x: Self, alpha: Self, beta: Self, n: u32, m: u32) -> Self

fn gaussian<P: Policy>(x: Self, a: Self, c: Self) -> Self

fn lbeta<P: Policy>(a: Self, b: Self) -> Self

fn logit<P: Policy>(self) -> Self

fn logit_1m<P: Policy>(self) -> Self

fn planck<P: Policy>(self) -> Self

fn legendre0<P: Policy, const N: u32>(x: Self, n: u32) -> Self

fn legendre<P: Policy>(x: Self, n: u32, m: u32) -> Self

fn legendre_series_n<P: Policy, const N: usize>( self, coeffs: &[Self::Element; N], ) -> Self

fn legendre_series<P: Policy>(self, coeffs: &[Self::Element]) -> Self

fn zernike_r<P: Policy>(rho: Self, n: u32, m: u32) -> Self

fn zernike<P: Policy, const NORM: u8>( rho: Self, theta: Self, n: u32, m: i32, ) -> Self

fn zernike_basis<P: Policy, const L: usize, const NORM: u8, const N: usize>( x: Self, y: Self, out: &mut [Self; N], )

fn phi_n<P: Policy, const N: usize>(self) -> Self

fn phi<P: Policy>(self, n: u32) -> Self

The runtime-order twin of phi_n. The f32/f64 backends override it with a term count worked out from n per call.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<V> SpecializedSpecialMath<f32> for V

where V: TranscendentalMathWithPolicy<Element = f32> + SpecializedTranscendentalMath<f32> + PrimalProjection<Primal = V> + RealMathWithPolicy<Element = f32> + FloatVectorWithBits<Element = f32>,

const LAGUERRE_PRODUCT_SEED_CAP: i32 = 29

type ExpIntDetails = V

impl<V> SpecializedSpecialMath<f64> for V

where V: TranscendentalMathWithPolicy<Element = f64> + SpecializedTranscendentalMath<f64> + PrimalProjection<Primal = V> + RealMathWithPolicy<Element = f64> + FloatVectorWithBits<Element = f64>,

const LAGUERRE_PRODUCT_SEED_CAP: i32 = 170

type ExpIntDetails = V