Struct TwoSeed 

pub struct TwoSeed<const K: usize> {
    pub base: Order2<K>,
    pub eps: Order2<K>,
    pub del: Order2<K>,
    pub eps_del: Order2<K>,
}

Two-seed scalar: an Order2 base plus TWO nilpotents ε, δ (ε² = δ² = 0, εδ retained) — four Order2 parts s = base + ε·eps + δ·del + εδ·eps_del.

Product truncates ε² = δ² = 0 (doc §A.3): each part is built from Order2 products of the four input parts. Composition picks up successively higher outer derivatives, the cross part carrying the second Faà di Bruno term f''·eps·del + f'·eps_del.

Seed each primary with seed: base = variable(x, axis), eps = constant(u_axis), del = constant(v_axis), eps_del = constant(0). Then the εδ-component of the evaluated Hessian channel is the contracted fourth [eps_del.h][a][b] = Σ_{cd} ℓ_{abcd} u_c v_d — exactly row_fourth_contracted(u, v), without materialising t4.

Fields

base: Order2<K>

The ε⁰δ⁰ part: value / grad / Hessian of ℓ.

eps: Order2<K>

The ε¹δ⁰ part.

del: Order2<K>

The ε⁰δ¹ part.

eps_del: Order2<K>

The ε¹δ¹ part. After a seed(u, v) evaluation, eps_del.h[a][b] = Σ_{cd} ℓ_{abcd} u_c v_d.

Implementations

impl<const K: usize> TwoSeed<K>

pub fn seed(x: f64, axis: usize, u_axis: f64, v_axis: f64) -> Self

Seed primary axis at value x with ε-direction u_axis and δ-direction v_axis: p_axis = p_axis⁰ + x-seed + ε·u_axis + δ·v_axis (doc §A.3 “Seeding”).

pub fn contracted_fourth(&self) -> [[f64; K]; K]

The contracted-fourth channel after a seed(u, v) evaluation: out[a][b] = Σ_{cd} ℓ_{abcd} u_c v_d, i.e. the εδ-coefficient’s Hessian.

Trait Implementations

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

fn clone(&self) -> TwoSeed<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 TwoSeed<K>

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

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

Formats the value using the given formatter.

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

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.