Struct RuntimeValue 

pub struct RuntimeValue { /* private fields */ }

Zero-order runtime scalar for evaluating the primal value of a canonical runtime-width row program without constructing derivative channels.

The primary dimension remains part of the scalar so it obeys the same runtime algebra contract as derivative-carrying implementations. Unary derivative stacks contribute only their value entry, while structured quadratic operators retain their representation-specific primal lowering.

Trait Implementations

impl Clone for RuntimeValue

fn clone(&self) -> RuntimeValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RuntimeValue

impl Debug for RuntimeValue

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

Formats the value using the given formatter.

impl PartialEq for RuntimeValue

fn eq(&self, other: &RuntimeValue) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'arena> RuntimeJetScalar<'arena> for RuntimeValue

type Workspace = ()

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 Self::Workspace) -> Self

A constant in a dimension-primary algebra.

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

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

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

Sum unary compositions whose inputs each carry an affine scale.

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, derivative_stack: [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 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 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.

impl StructuralPartialEq for RuntimeValue