Struct DynamicTwoSeed 

pub struct DynamicTwoSeed<'arena> {
    pub base: DynamicOrder2<'arena>,
    pub eps: DynamicOrder2<'arena>,
    pub del: DynamicOrder2<'arena>,
    pub eps_del: DynamicOrder2<'arena>,
}

Runtime-sized two-seed scalar for a Hessian-contracted fourth derivative.

Fields

base: DynamicOrder2<'arena>

Base value/gradient/Hessian channels.

eps: DynamicOrder2<'arena>

Nilpotent epsilon coefficient.

del: DynamicOrder2<'arena>

Nilpotent delta coefficient.

eps_del: DynamicOrder2<'arena>

Mixed epsilon delta coefficient.

Implementations

impl<'arena> DynamicTwoSeed<'arena>

pub fn seed( x: f64, axis: usize, u_axis: f64, v_axis: f64, dimension: usize, arena: &'arena DynamicJetArena, ) -> Self

Seed one primary with both contraction direction components.

pub fn contracted_fourth(&self) -> &[f64]

Row-major contracted-fourth matrix.

Trait Implementations

impl<'arena> Clone for DynamicTwoSeed<'arena>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'arena> Copy for DynamicTwoSeed<'arena>

impl<'arena> Debug for DynamicTwoSeed<'arena>

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

Formats the value using the given formatter.

impl<'arena> RuntimeJetScalar<'arena> for DynamicTwoSeed<'arena>

type Workspace = DynamicJetArena

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, arena: &'arena DynamicJetArena) -> Self

A constant in a dimension-primary algebra.

fn variable( x: f64, axis: usize, dimension: usize, arena: &'arena DynamicJetArena, ) -> 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, o: &Self) -> Self

Exact truncated sum.

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

Exact truncated difference.

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

Exact truncated product.

fn neg(&self) -> Self

Negate every channel.

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

Scale every channel.

fn compose_unary(&self, d: [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 weighted_compose_sum( lefts: &[Self], right: &Self, derivative_stacks: &[[f64; 5]], addend: &Self, ) -> Self

addend + Sum_i lefts[i] * f_i(right) from certified derivative stacks, with ONE shared composition point.

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.