Struct DynamicOrder2 

pub struct DynamicOrder2<'arena> {
    pub v: f64,
    pub g: &'arena [f64],
    pub h: &'arena [f64],
    /* private fields */
}

Runtime-sized packed second-order scalar: value, gradient, and a row-major Hessian. Storage is O(K^2) in the row’s actual primary dimension and comes from the row’s reusable DynamicJetArena.

Fields

v: f64

Value channel.

g: &'arena [f64]

Gradient channel.

h: &'arena [f64]

Row-major Hessian channel.

Implementations

impl DynamicOrder2<'_>

pub fn from_channel_functions<'arena>( value: f64, dimension: usize, arena: &'arena DynamicJetArena, gradient: impl FnMut(usize) -> f64, hessian: impl FnMut(usize, usize) -> f64, ) -> DynamicOrder2<'arena>

Construct an arena-backed second-order scalar from channel functions.

This is the allocation-free extension seam for exact projected products whose channel law is not ordinary scalar multiplication. Each channel is written directly into the row arena, so downstream runtime-jet programs can keep their specialized algebra without materializing temporary Vecs or exposing the arena pointer stored by DynamicOrder2. The Hessian function is evaluated on the upper triangle and mirrored because a scalar Hessian is symmetric.

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

Gradient channel.

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

Row-major Hessian channel.

impl<'arena> DynamicOrder2<'arena>

pub fn scaled_product_sum( scales: &[f64], lefts: &[Self], rights: &[Self], ) -> Self

Σ_k scales[k] · lefts[k] · rights[k] in one pass over the result.

The one-seed batch’s epsilon lanes are sums of products of order-two jets; forming each product and each partial sum as its own jet would allocate and stream 2k − 1 intermediate blocks for a result that is one block.

pub fn product_pair_sum_plus( a: &Self, b: &Self, c: &Self, d: &Self, e: &Self, ) -> Self

a·b + c·d + e in one pass over the result.

Trait Implementations

impl<'arena> Clone for DynamicOrder2<'arena>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'arena> Copy for DynamicOrder2<'arena>

impl<'arena> Debug for DynamicOrder2<'arena>

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

Formats the value using the given formatter.

impl<'arena> RuntimeJetScalar<'arena> for DynamicOrder2<'arena>

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

addend + Σ_i L_i · f_i(R) in ONE output block.

Every f_i(R) shares the composition point, so its channels are (s0_i, s1_i·R.g, s1_i·R.h + s2_i·R.g⊗R.g) and the product with L_i expands to

v   = Σ L_i.v·s0_i
g_a = Σ (L_i.v·s1_i)·R.g_a + s0_i·L_i.g_a
h_ab = Σ (L_i.v·s1_i)·R.h_ab + (L_i.v·s2_i)·R.g_a·R.g_b
         + s1_i·(L_i.g_a·R.g_b + R.g_a·L_i.g_b) + s0_i·L_i.h_ab

so the R-dependent coefficients collapse into two scalars, Σ L_i.v·s1_i and Σ L_i.v·s2_i, that multiply R.h and R.g⊗R.g ONCE. The default walks the same algebra through 2N intermediate jets, each of which allocates and streams its own n² block; this writes one.

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 symmetric_quadratic_form<C: SymmetricQuadraticCoefficients>( inputs: &[Self], coefficients: &C, dimension: usize, arena: &'arena DynamicJetArena, ) -> Self

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

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

Sum unary compositions directly from certified derivative stacks.

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

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

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 add_constant(&self, constant: f64) -> Self

Add a primal constant without changing derivative channels.

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.