Struct Tower3 

pub struct Tower3<const K: usize> {
    pub v: f64,
    pub g: [f64; K],
    pub h: [[f64; K]; K],
    pub t3: [[[f64; K]; K]; K],
}

Truncated THIRD-order multivariate Taylor scalar in K variables.

The value/gradient/Hessian/third-derivative sibling of Tower4, standing between Tower2 and Tower4. Every channel it carries (v, g, h, t3) is computed by the SAME shared Leibniz / Faà-di-Bruno kernels Tower4 uses for those orders, and the order-≤3 terms of those kernels read only the order-≤3 channels of their inputs (the order-3 Faà-di-Bruno partitions never reach the f⁗ stack slot or the inner t4 tensor — see Tower4::compose_unary). So for any program written over both towers the order-≤3 outputs are bit-identical: dropping the fourth tensor cannot perturb the value, gradient, Hessian, or third derivatives.

It exists purely for performance, exactly like Tower2: a consumer that needs up to third derivatives (the survival location-scale row kernel reads g, the diagonal h, and the diagonal t3, but never t4) pays the K³ third-tensor arithmetic but skips the K⁴ fourth-tensor product/composition that otherwise dominates the per-row cost.

Fields

v: f64

Value ℓ.

g: [f64; K]

Gradient ∂ℓ/∂p_a.

h: [[f64; K]; K]

Hessian ∂²ℓ/∂p_a∂p_b (symmetric).

t3: [[[f64; K]; K]; K]

Third derivatives ∂³ℓ/∂p_a∂p_b∂p_c (fully symmetric).

Implementations

impl<const K: usize> Tower3<K>

pub fn zero() -> Self

The additive identity.

pub fn constant(c: f64) -> Self

A constant: value c, all derivatives zero.

pub fn variable(value: f64, idx: usize) -> Self

The seeded variable p_idx with current value value: unit first derivative in slot idx, zero elsewhere and above.

pub fn mul(&self, o: &Self) -> Self

Exact truncated (order ≤ 3) Leibniz product. The v/g/h/t3 channels match Tower4::mul term-for-term.

Codegen

Straight-line per-entry subset sums instead of the [jet_algebra::leibniz_product] walker — the order-≤3 sibling of Tower4::mul (no t4). Loop nest unchanged, no unroll over K, no code bloat; auto-vectorises. BIT-IDENTICAL: terms in the walker’s exact subset order with an acc = 0.0 accumulator start (load-bearing for the signed-zero leading product on exact-0.0 jet channels). Proven to_bits-identical on v/g/h/t3 across K ∈ {2,3,4,9}, 5000 zero/sign-stressed inputs each (these channel formulas are exactly the g/h/t3 of the Tower4::mul oracle, which passes that stress).

pub fn add(&self, o: &Self) -> Self

Ref-taking elementwise sum, the by-ref twin of the std::ops::Add operator (which consumes by value). Mirrors the inherent mul/scale API so a chain like a.mul(&b).add(&c) reads uniformly without moving out of the borrowed operands.

pub fn sub(&self, o: &Self) -> Self

Ref-taking elementwise difference, the by-ref twin of std::ops::Sub.

pub fn compose_unary(&self, d: [f64; 4]) -> Self

Exact (order ≤ 3) multivariate Faà di Bruno composition f ∘ self.

d = [f(u), f′(u), f″(u), f‴(u)] evaluated at u = self.v. The v/g/h/t3 channels match Tower4::compose_unary term-for-term (which uses only d[0..=3] for those orders), so this is a strict truncation, not an approximation. The full-order [f64; 5] derivative stacks the families already produce can be passed by slicing their first four entries.

Codegen

Order-≤3 Faà di Bruno written as a compact closed form instead of the recursive jet_algebra::faa_di_bruno walker — the order-≤2 sibling of Tower4::compose_unary, one tensor order shallower. The loop nest is unchanged (no unroll over K, no code bloat: measured on a Tower3<9> compose-and-read consumer the new form is faster and SMALLER — asm: 71 walker bl calls → 0, 39.5 KiB → 13.9 KiB, +197 NEON .2d ops). BIT-IDENTICAL: terms in the walker’s exact partition order, left- associated block products, acc = 0.0 accumulator start. Proven to_bits-identical on v/g/h/t3 across K ∈ {2,3,4,9}, 5000 random inputs each.

pub fn compose_unary_with(&self, stack_fn: impl Fn(f64) -> [f64; 4]) -> Self

Compose with a unary special-function whose [f64; 4] derivative STACK is built from the base value through stack_fn — the scalar arm of the generic-over-Lane compose seam (see Tower3Lane::compose_unary_with). Evaluates stack_fn(self.v) ONCE and forwards to Self::compose_unary, so it is BIT-IDENTICAL to the explicit self.compose_unary(stack_fn(self.v)). The order-≤3 sibling of Tower4::compose_unary_with.

pub fn compose_unary_single_slot(&self, d: [f64; 4], slot: usize) -> Self

Single-active-slot fast path for Self::compose_unary — the order-≤3 sibling of Tower4::compose_unary_single_slot. When self carries derivative support only on the all-slot diagonal, every output channel touching an axis ≠ slot collapses to the walker’s total = 0.0 start (+0.0), so only v, g[slot], h[slot][slot], t3[slot]³ survive. These four are computed as STRAIGHT-LINE accumulations, each in the EXACT term order of Self::compose_unary’s diagonal (i = j = k = slot) case (BIT-IDENTICAL to the full path on the diagonal); off-slot channels stay at the zero-init +0.0 the full walk also yields (proven to_bits across K ∈ {2,3,4,9}). This drops the recursive set-partition walker the diagonal channels previously routed through, recovering its measured ~5.9× regression at the K ∈ {2,3} BMS tower widths. Caller guarantees the single-slot precondition; otherwise use Self::compose_unary.

pub fn scale(&self, s: f64) -> Self

Multiply every channel by a plain scalar.

Trait Implementations

impl<const K: usize> Add for Tower3<K>

type Output = Tower3<K>

The resulting type after applying the + operator.

fn add(self, o: Self) -> Self

Performs the + operation.

impl<const K: usize> Clone for Tower3<K>

fn clone(&self) -> Tower3<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const K: usize> Copy for Tower3<K>

impl<const K: usize> Debug for Tower3<K>

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

Formats the value using the given formatter.

impl<const K: usize> JetScalar<K> for Tower3<K>

The order-≤3 crate::jet_tower::Tower3 is also a JetScalar. It serves consumers that read .t3 but never .t4, avoiding the fourth-tensor product/composition work while preserving the lower channels bit-for-bit against crate::jet_tower::Tower4.

fn constant(c: f64) -> Self

A constant: value c, every derivative channel zero.

fn variable(x: f64, axis: usize) -> Self

The seeded variable p_axis at value x: unit first derivative in slot axis, all higher channels zero. (The nilpotent / cross channels of the directional scalars are seeded zero — callers set ε/δ directions through the scalar-specific OneSeed::seed_direction / TwoSeed::seed.)

fn value(&self) -> f64

The value channel ℓ(p).

fn add(&self, o: &Self) -> Self

Exact truncated Leibniz sum self + o.

fn sub(&self, o: &Self) -> Self

Exact truncated Leibniz difference self − o.

fn mul(&self, o: &Self) -> Self

Exact truncated Leibniz product self · o.

fn neg(&self) -> Self

Negate every channel.

fn scale(&self, s: f64) -> Self

Multiply every channel by a plain scalar s.

fn compose_unary(&self, d: [f64; 5]) -> Self

Exact multivariate Faà di Bruno composition f ∘ self, given the outer derivative stack d = [f(u), f′(u), f″(u), f‴(u), f⁗(u)] at u = self.value().

fn compose_unary_with(&self, stack_fn: impl Fn(f64) -> [f64; 5]) -> Self

Compose with a unary special-function whose derivative STACK is built from the scalar base value through stack_fn — the generic-over-Lane seam that lets a single-sourced row program instantiate at BOTH the scalar f64 jets and the SIMD f64x4 batch towers from ONE expression.

fn exp(&self) -> Self

e^self. Convenience for tame arguments (see module stability note).

fn sqrt(&self) -> Self

√self. Caller guarantees positivity.

fn ln(&self) -> Self

ln(self). Caller guarantees positivity. Same derivative stack crate::jet_tower::Tower4::ln uses, so any program written over both matches term-for-term.

fn recip(&self) -> Self

1/self.

fn powf(&self, a: f64) -> Self

self^a for real exponent a. Caller guarantees a positive base. Mirrors crate::jet_tower::Tower4::powf (falling-factorial stack).

fn ln_gamma(&self) -> Self

ln Γ(self). Caller guarantees a positive argument. Uses the SAME hand-certified derivative stack crate::jet_tower::Tower4::ln_gamma consumes (crate::jet_tower::ln_gamma_derivative_stack), so any program written over both matches term-for-term.

fn digamma(&self) -> Self

ψ(self) = d/dx ln Γ(x) (digamma). Caller guarantees a positive argument. Same hand-certified stack crate::jet_tower::digamma_derivative_stack.