Struct DynamicOneSeedBatch 

pub struct DynamicOneSeedBatch<'arena> {
    pub base: DynamicOrder2<'arena>,
    /* private fields */
}

Runtime-sized batch of one-seed contractions sharing one order-two base.

Lane l is algebraically identical to a standalone DynamicOneSeed seeded by direction u_l, but the value/gradient/Hessian base is evaluated once rather than once per direction. The output lane’s epsilon Hessian is sum_c d³f/(dx_a dx_b dx_c) u_l[c].

Fields

base: DynamicOrder2<'arena>

Shared value/gradient/Hessian channels.

Implementations

impl<'arena> DynamicOneSeedBatch<'arena>

pub fn seed_directions( x: f64, axis: usize, dimension: usize, workspace: &'arena DynamicJetBatchWorkspace, direction_at: impl FnMut(usize) -> f64, ) -> Self

Seed one primary across every direction lane.

pub fn lanes(&self) -> usize

Number of simultaneous contraction directions.

pub fn contracted_third(&self, lane: usize) -> &[f64]

Row-major contracted-third matrix for one direction lane.

Trait Implementations

impl<'arena> Clone for DynamicOneSeedBatch<'arena>

fn clone(&self) -> DynamicOneSeedBatch<'arena>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'arena> Copy for DynamicOneSeedBatch<'arena>

impl<'arena> Debug for DynamicOneSeedBatch<'arena>

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

Formats the value using the given formatter.

impl<'arena> RuntimeJetScalar<'arena> for DynamicOneSeedBatch<'arena>

fn weighted_compose_sum( lefts: &[Self], right: &Self, derivative_stacks: &[[f64; 5]], addend: &Self, ) -> Self

addend + Σ_i L_i · f_i(R) with ONE shared composition point, lane by lane, on top of the base type’s fused form.

The nilpotent part of f_i(R) is f_i'(R.base)·R.eps_l, so lane l is

addend.eps_l + Σ_i L_i.base·f_i'(R.base)·R.eps_l + Σ_i L_i.eps_l·f_i(R.base)
             = R.eps_l · [Σ_i L_i.base·f_i'(R.base)]  +  Σ_i L_i.eps_l·f_i(R.base)

and BOTH bracketed sums are the base type’s weighted_compose_sum at the same point R.base — the first with the derivative stacks shifted by one, the second with the stacks themselves. The first does not depend on the lane, so it is formed once for the whole batch. The loop this replaces wrote 2N blocks in EVERY lane and in the base; this writes two shared blocks plus three per lane (gam#979).

type Workspace = DynamicJetBatchWorkspace

Storage arena used by runtime-backed scalars. Fixed derivative oracles use the unit type because their storage is inline.

fn constant( c: f64, dimension: usize, workspace: &'arena DynamicJetBatchWorkspace, ) -> Self

A constant in a dimension-primary algebra.

fn variable( x: f64, axis: usize, dimension: usize, workspace: &'arena DynamicJetBatchWorkspace, ) -> Self

A seeded variable in a dimension-primary algebra.

fn constant_like(&self, c: f64) -> Self

A constant in the same runtime algebra as self.

fn with_value(&self, value: f64) -> Self

Replace only the primal value, preserving every derivative channel.

fn dimension(&self) -> usize

Number of primary derivative axes carried by this scalar.

fn value(&self) -> f64

Value channel.

fn add(&self, other: &Self) -> Self

Exact truncated sum.

fn sub(&self, other: &Self) -> Self

Exact truncated difference.

fn mul(&self, other: &Self) -> Self

Exact truncated product.

fn multiply_add(&self, right: &Self, addend: &Self) -> Self

Evaluate self * right + addend in one semantic primitive.

fn linear_combination( inputs: &[Self], weights: &[f64], dimension: usize, workspace: &'arena DynamicJetBatchWorkspace, ) -> Self

Evaluate sum_i weights[i] * inputs[i] in one semantic primitive.

fn affine_composed_sum( inputs: &[Self], input_scales: &[f64], derivative_stacks: &[[f64; 5]], dimension: usize, workspace: &'arena DynamicJetBatchWorkspace, ) -> Self

Sum unary compositions whose inputs each carry an affine scale.

fn neg(&self) -> Self

Negate every channel.

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

Scale every channel.

fn compose_unary(&self, derivatives: [f64; 5]) -> Self

Exact unary composition from the certified derivative stack.

fn symmetric_quadratic_form<C: SymmetricQuadraticCoefficients>( inputs: &[Self], coefficients: &C, dimension: usize, workspace: &'arena Self::Workspace, ) -> Self

Evaluate inputs' A inputs from the same universal semantic primitive as JetScalar::symmetric_quadratic_form.

fn add_constant(&self, constant: f64) -> Self

Add a primal constant without changing derivative channels.

fn composed_sum( inputs: &[Self], derivative_stacks: &[[f64; 5]], dimension: usize, workspace: &'arena Self::Workspace, ) -> Self

Sum unary compositions directly from certified derivative stacks.

fn product(&self, right: &Self) -> Self

Exact product as an explicit compiled graph node.

fn affine_compose( &self, input_scale: f64, input_shift: f64, derivative_stack: [f64; 5], ) -> Self

Compose a certified outer stack after an affine input map.

fn shared_multiply_add_affine_composed_sum<const N: usize>( lefts: &[&Self; N], right: &Self, addend: &Self, addend_scales: &[f64; N], input_scales: &[f64; N], derivative_stacks: &[[f64; 5]; N], dimension: usize, workspace: &'arena Self::Workspace, ) -> Self

Runtime-dimension lowering of Σ_i f_i(input_scale_i · (left_i · right + addend_scale_i · addend)) from certified derivative stacks. Const expression arity replaces an implementation-specific term cap, while shared operands expose universal common-subexpression elimination. If every addend scale is exact zero (including -0.0), the addend has no dimension, workspace, or derivative-channel obligations.

fn exp(&self) -> Self

e^self.

fn ln(&self) -> Self

ln(self). Caller guarantees positivity. This is the runtime-width counterpart of JetScalar::ln and uses the identical certified derivative stack.

fn recip(&self) -> Self

1/self.