Struct TwoSeedLane 

pub struct TwoSeedLane<L: Lane, const K: usize> {
    pub base: Order2Lane<L, K>,
    pub eps: Order2Lane<L, K>,
    pub del: Order2Lane<L, K>,
    pub eps_del: Order2Lane<L, K>,
}

Lane-batched TwoSeed: the same two-seed scalar with its four Order2 parts re-typed to Order2Lane<L, K>, so one L = f64x4 instance carries FOUR rows’ contracted-fourth evaluations per vector pass.

Every operation is a term-for-term structural re-type of the scalar TwoSeed ops onto the lane-implemented Order2Lane algebra. With L = f64, TwoSeedLane<f64, K> is to_bits-identical to TwoSeed<K>; with L = f64x4, lane i is to_bits-identical to that (see batch_tests).

Fields

base: Order2Lane<L, K>

The ε⁰δ⁰ part.

eps: Order2Lane<L, K>

The ε¹δ⁰ part.

del: Order2Lane<L, K>

The ε⁰δ¹ part.

eps_del: Order2Lane<L, K>

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

Implementations

impl<L: Lane, const K: usize> TwoSeedLane<L, K>

pub fn constant(c: L) -> Self

A constant: base = constant(c), all seed parts zero (mirrors TwoSeed::constant).

pub fn variable(value: L, axis: usize) -> Self

The seeded variable p_axis at (per-lane) value value, no ε/δ direction (mirrors TwoSeed::variable).

pub fn seed(value: L, axis: usize, u_axis: L, v_axis: L) -> Self

Seed primary axis at (per-lane) value value with ε-direction u_axis and δ-direction v_axis (mirrors TwoSeed::seed). With L = f64x4, each argument packs the four rows’ values for primary axis.

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

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

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

Lane-wise self + o (mirrors TwoSeed::add).

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

Lane-wise self - o (mirrors TwoSeed::sub).

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

Lane-wise self · o, ε² = δ² = 0 truncation (mirrors TwoSeed::mul).

pub fn neg(&self) -> Self

Negate every part (mirrors TwoSeed::neg).

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

Multiply every part by the plain scalar s (mirrors TwoSeed::scale).

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

Exact composition f ∘ self, given the per-lane outer-derivative stack d = [f, f′, f″, f‴, f⁗]. Term-for-term identical to TwoSeed::compose_unary: base reads d[0..=2], f′(base) reads d[1..=3], f″(base) reads d[2..=4], and the cross part carries f″·eps·del + f′·eps_del.

pub fn exp(&self) -> Self

e^self, per-lane stack [e; 5] (matches JetScalar::exp).

pub fn ln(&self) -> Self

ln(self); caller guarantees positivity (matches JetScalar::ln).

pub fn sqrt(&self) -> Self

√self; caller guarantees positivity (matches JetScalar::sqrt).

pub fn recip(&self) -> Self

1/self (matches JetScalar::recip).

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

self^a for real a; caller guarantees a positive base (matches JetScalar::powf).

pub fn ln_gamma(&self) -> Self

ln Γ(self); caller guarantees positivity (matches JetScalar::ln_gamma).

pub fn digamma(&self) -> Self

ψ(self) digamma; caller guarantees positivity (matches JetScalar::digamma).

impl<const K: usize> TwoSeedLane<f64x4, K>

pub fn lane(&self, i: usize) -> TwoSeed<K>

Extract lane i’s parts as a production TwoSeed<K>. Lane i is to_bits-identical to evaluating the same program at TwoSeed<K> on row i (see batch_tests).

Trait Implementations

impl<L: Clone + Lane, const K: usize> Clone for TwoSeedLane<L, K>

fn clone(&self) -> TwoSeedLane<L, K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Copy + Lane, const K: usize> Copy for TwoSeedLane<L, K>

impl<L: Debug + Lane, const K: usize> Debug for TwoSeedLane<L, K>

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

Formats the value using the given formatter.