Struct ShTable 

#[repr(C)]
pub struct ShTable<E, const N: usize> {
    pub qmm: [E; N],
    pub em: [E; N],
    pub a: [E; N],
    pub nb: [E; N],
    pub f: [E; N],
    pub mf: [E; N],
}

Precomputed recurrence coefficients for all (l, m) with l <= L.

Every array is sized N = (L+1)^2 (the flat output size) rather than its exact need, because the exact sizes (L+1, triangular) are generic const expressions that stable Rust cannot spell in a type. The waste is compile-time data only.

Indexing: qmm and em by m, and a, nb, f by tri(l) + m.

Instantiated two ways. ShTable<E, N> over a scalar element is the compile-time form behind ShConsts, read by the unrolled kernels. ShTable<V, N> over a vector is the runtime form produced by sh_table_impl and consumed by sh_eval_impl, which is what lifts the degree cap and makes the kernels work on element types that have no const table.

#[repr(C)] so that the two are layout-compatible when the element and vector types are (the scalar-math layer reinterprets &mut ShTable<f32, N> as &mut ShTable<Vector<f32>, N>). repr(Rust) gives no such guarantee across distinct type arguments.

Clone but deliberately not Copy: a table is 6 * N elements (about 4.8 KB at L = 4 on f32x8, 54 KB at L = 16), and implicit copies of that are not something to make easy. Pass it by reference. It is read-only after filling.

Fields

qmm: [E; N]

Diagonal values q_m^m, pure constants, since the $\sin^m\theta$ that made the diagonal z-dependent lives in the azimuthal recurrence instead.

em: [E; N]

First off-diagonal step: q_{m+1}^m = em[m] * z * q_m^m, em[m] = sqrt(2m+3).

a: [E; N]

Three-term recurrence: q_l^m = a * z * q_{l-1}^m + nb * q_{l-2}^m.

nb: [E; N]

The b coefficient, stored negated so the recurrence is a single mul_adde.

f: [E; N]

z-derivative norm ratio: d(q_l^m)/dz = f[tri(l)+m] * q_l^{m+1} (zero at m = l).

mf: [E; N]

m as a float, for the azimuthal derivative factor (d c_m = m c_{m-1} etc.).

Implementations

impl<V: FloatVector, const N: usize> ShTable<V, N>

pub fn zeroed() -> Self

An all-zero table, to be filled by sh_table_impl.

pub fn lift<W>(&self) -> ShTable<W, N>

where W: FloatVector + PrimalProjection<Primal = V>,

Lifts every entry into a composite W whose primal is V, via from_primal, so constants with zeroed augmentation. The identity copy when W is its own primal.

Hand-rolled loops rather than array::map, which fails to inline in target_feature code.

Trait Implementations

impl<E: Clone, const N: usize> Clone for ShTable<E, N>

fn clone(&self) -> ShTable<E, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug, const N: usize> Debug for ShTable<E, N>

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

Formats the value using the given formatter.

impl<'a, R, const N: usize> Unwrap for &'a ShTable<Vector<R>, N>

where R: Register<Storage = R>,

Scalar-layer bridge for the table arguments, mirroring thermite’s Unwrap for &mut [Vector<R>; N].

The ScalarSpecialMath aggregate runs the vector kernels at width 1, wrapping each argument on the way in. A table is a by-reference parameter, so it is reinterpreted in place rather than copied. This is sound because Vector<R> is #[repr(transparent)] over Storage<R>, R: Register<Storage = R> pins that to R, and ShTable is #[repr(C)] so the two instantiations agree on layout.

type Unwrapped = &'a ShTable<R, N>

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

fn unwrap(self) -> Self::Unwrapped

impl<'a, R, const N: usize> Unwrap for &'a mut ShTable<Vector<R>, N>

where R: Register<Storage = R>,

type Unwrapped = &'a mut ShTable<R, N>

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

fn unwrap(self) -> Self::Unwrapped