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>

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 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 linear_combination( inputs: &[Self], weights: &[f64], dimension: usize, workspace: &'arena Self::Workspace, ) -> Self

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

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

Add a primal constant without changing derivative channels.

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

Evaluate self * right + addend in one semantic primitive.

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 affine_composed_sum( inputs: &[Self], input_scales: &[f64], derivative_stacks: &[[f64; 5]], dimension: usize, workspace: &'arena Self::Workspace, ) -> Self

Sum unary compositions whose inputs each carry an affine scale.

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.