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.

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.

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.