Struct Order2Lane 

pub struct Order2Lane<L: Lane, const K: usize> {
    pub v: L,
    pub g: [L; K],
    pub h: [[L; K]; K],
}

A lane-batched order-≤2 Taylor scalar: value / gradient / Hessian carried in a SIMD field L: Lane. With L = f64x4 one instance carries FOUR rows at once, so the row loop processes 4 rows per vector pass instead of one per scalar pass.

The channel layout and every float op mirror crate::jet_tower::Tower2 term-for-term, so Order2Lane<f64, K> is to_bits-identical to the production Order2<K> and Order2Lane<f64x4, K> lane i is to_bits-identical to that (see the module note and batch_tests).

Fields

v: L

Value channel ℓ (one entry per lane/row).

g: [L; K]

Gradient channel ∂ℓ/∂p_a.

h: [[L; K]; K]

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

Implementations

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

pub fn constant(c: L) -> Self

A constant: value c in every channel-zero slot.

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

The seeded variable p_axis at (per-lane) value value: unit first derivative in slot axis. With L = f64x4, value packs the four rows’ values of primary axis.

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

Lane-wise self + o (mirrors Tower2 Add: per-channel add).

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

Multiply every channel by the plain scalar s (mirrors Tower2::scale).

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

Lane-wise self - o, expressed as self + o·(-1) exactly as Order2::sub / Tower4::sub do, so signed-zero handling matches.

pub fn neg(&self) -> Self

Negate every channel (= scale(-1.0), matching Order2::neg).

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

Exact order-≤2 Leibniz product, term-for-term identical to crate::jet_tower::Tower2::mul (same factor order, no mul_add).

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

Exact order-≤2 Faà di Bruno composition f ∘ self, given the per-lane derivative stack d = [f(u), f′(u), f″(u)]. Mirrors crate::jet_tower::Tower2::compose_unary term-for-term (acc starts at 0 then accumulates, so signed-zero collapses identically).

pub fn exp(&self) -> Self

e^self, per-lane stack [e, e, e] (matches the JetScalar::exp default forwarded through Order2).

pub fn ln(&self) -> Self

ln(self); caller guarantees positivity. Per-lane stack [ln u, 1/u, -1/u²] (matches JetScalar::ln truncated to order 2).

pub fn sqrt(&self) -> Self

√self; caller guarantees positivity. Per-lane stack [s, 0.5/s, -0.25/(u·s)] (matches JetScalar::sqrt).

pub fn recip(&self) -> Self

1/self. Per-lane stack [r, -r², 2r³] (matches JetScalar::recip).

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

self^a for real a; caller guarantees a positive base. Per-lane falling-factorial stack (matches JetScalar::powf).

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

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

Extract lane i’s (v, g, H) as a production Order2<K> scalar. Lane i is to_bits-identical to evaluating the same program at Order2<K> on row i (see batch_tests).

Trait Implementations

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

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

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

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

Formats the value using the given formatter.