Struct OneSeedLane 

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

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

Every operation (add/sub/mul/neg/scale/compose_unary and the transcendentals) is a term-for-term structural re-type of the scalar OneSeed ops onto the lane-implemented Order2Lane algebra. With L = f64, OneSeedLane<f64, K> is to_bits-identical to OneSeed<K>; with L = f64x4, lane i is to_bits-identical to that (see batch_tests).

Fields

base: Order2Lane<L, K>

The ε⁰ part (lane-batched value / gradient / Hessian of ℓ).

eps: Order2Lane<L, K>

The ε¹ part. After a seed_direction(u) evaluation, eps.h[a][b] lane i is row i’s Σ_c ℓ_{abc} u_c.

Implementations

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

pub fn constant(c: L) -> Self

A constant: base = constant(c), ε-part zero (mirrors OneSeed::constant).

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

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

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

Seed primary axis at (per-lane) value value with ε-direction component u_axis: base = variable(value, axis), eps = constant(u_axis) (mirrors OneSeed::seed_direction). With L = f64x4, value / u_axis pack the four rows’ values / directions of primary axis.

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

The contracted-third channel after a seed_direction(u) evaluation: out[a][b] lane i is row i’s Σ_c ℓ_{abc} u_c (the ε-part Hessian).

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

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

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

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

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

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

pub fn neg(&self) -> Self

Negate every part (mirrors OneSeed::neg).

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

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

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

Exact order-≤2-per-part Faà di Bruno composition f ∘ self, given the per-lane outer-derivative stack d = [f, f′, f″, f‴, f⁗]. Term-for-term identical to OneSeed::compose_unary: the base reads d[0..=2] and the ε-coefficient is f′(base) (reads d[1..=3]) times eps.

pub fn exp(&self) -> Self

e^self, per-lane stack [e, e, e, e, e] (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, same hand-certified stack).

pub fn digamma(&self) -> Self

ψ(self) digamma; caller guarantees positivity (matches JetScalar::digamma, same hand-certified stack).

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

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

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

Trait Implementations

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

fn clone(&self) -> OneSeedLane<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 OneSeedLane<L, K>

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

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

Formats the value using the given formatter.