Enum BesselOrder 

pub enum BesselOrder<V, S> {
    Integer(S),
    HalfInteger(S),
    Thirds(S),
    Real(V),
}

The order $\nu$ for the runtime-order Bessel functions, tagged with the class of order it carries. See the module documentation for why the class is part of the value.

Variants are listed cheapest first. Every one stores its order per lane, so a packet may carry a different order in each lane. What it may not carry is a different class.

V is the float vector and S its signed-integer companion, in practice always BesselOrder<V, V::Signed>, which is what every entry point asks for and what inference produces from a plain BesselOrder::Integer(k). They are separate parameters rather than one because the scalar surface unwraps each payload independently.

Variants

Integer(S)

$\nu = k$, a whole number. Fitted minimax rationals at the low orders plus a recurrence. The cheapest class, and the only one reaching a coefficient table.

HalfInteger(S)

$\nu = k/2$. Half-integer orders are elementary: $J_{1/2}(x) = \sqrt{2/\pi x}\,\sin x$, $I_{1/2}(x) = \sqrt{2/\pi x}\,\sinh x$, $K_{1/2}(x) = \sqrt{\pi/2x}\,e^{-x}$, and the recurrence builds the rest with no continued fraction, $\Gamma$, or series. This is also the spherical Bessel family, via $j_n(x) = \sqrt{\pi/2x}\,J_{n+1/2}(x)$.

Thirds(S)

$\nu = k/3$. The Airy orders: $\mathrm{Ai}$ and $\mathrm{Bi}$ are Bessel functions at $\nu = \pm 1/3$ and their derivatives at $\nu = \pm 2/3$.

Costs the same as Real, and the variant promises no shortcut. No library has one, because there is none short of a dedicated minimax fit per order. What it buys is exactness: a caller who writes Thirds(1) gets the correctly-rounded $1/3$ rather than whatever they typed.

Real(V)

Arbitrary real $\nu$. The general algorithm, and the expensive one.

Implementations

impl<V: FloatVector> BesselOrder<V, V::Signed>

pub fn to_real(self) -> V

The order as a float vector.

Exact for Integer, HalfInteger and Real. Lossy for Thirds, necessarily, as thirds are not binary-representable, which is why the variant stores a numerator in the first place. Kernels that need an exact third must consume the numerator, not this.

pub fn as_integer(self) -> Option<V::Signed>

The whole-number order, if simplify reduces this to Integer.

None says the order genuinely is not whole, which is the question every entry point asks last, after it has checked for the cheaper classes it can serve directly.

pub fn simplify(self) -> Self

Narrow to the cheapest variant this data actually needs.

Requires the condition to hold in every lane. Never widens, never changes the value of $\nu$, and never turns Real into Thirds. See the module documentation for why that last one would be unsound.

Trait Implementations

impl<V: Clone, S: Clone> Clone for BesselOrder<V, S>

fn clone(&self) -> BesselOrder<V, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Copy, S: Copy> Copy for BesselOrder<V, S>

impl<V: Debug, S: Debug> Debug for BesselOrder<V, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V: Eq, S: Eq> Eq for BesselOrder<V, S>

impl<V: PartialEq, S: PartialEq> PartialEq for BesselOrder<V, S>

fn eq(&self, other: &BesselOrder<V, S>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<V: PartialEq, S: PartialEq> StructuralPartialEq for BesselOrder<V, S>

impl<V: Unwrap, S: Unwrap> Unwrap for BesselOrder<V, S>

Lets the generated scalar surface (scalar_bessel_jv and friends) carry an order: each payload unwraps on its own, which is the reason V and S are separate parameters.

type Unwrapped = BesselOrder<<V as Unwrap>::Unwrapped, <S as Unwrap>::Unwrapped>

fn wrap(value: Self::Unwrapped) -> Self

fn unwrap(self) -> Self::Unwrapped