Struct Dual2 

pub struct Dual2<S: JetField> {
    pub v: S,
    pub g: S,
    pub h: S,
}

A single-direction second-order jet over the field S: value v, first derivative g, second derivative h, all with respect to ONE seeded direction. Nest it (Dual2<Dual2<f64>>) for a second, independent direction.

Fields

v: S

Value channel.

g: S

First derivative in this dual’s direction.

h: S

Second derivative in this dual’s direction.

Implementations

impl<S: JetFieldConst> Dual2<S>

pub fn constant(v: S) -> Self

A constant (value v, zero derivatives) — carries no dependence on this dual’s direction (but v may still depend on an inner nested direction).

pub fn variable(v: S) -> Self

The seeded variable at v: unit first derivative in this dual’s direction, zero second derivative.

impl Dual2<Dual2<f64>>

pub fn seed_outer(x: f64) -> Self

Seed a primary that varies only along the OUTER direction a (∂/∂a = 1, ∂/∂b = 0) — the Tower4::variable(x, 0) analogue.

pub fn seed_inner(x: f64) -> Self

Seed a primary that varies only along the INNER direction b (∂/∂a = 0, ∂/∂b = 1) — the Tower4::variable(x, 1) analogue.

pub fn seed_directional(base: f64, d1: f64, d2: f64) -> Self

Seed a primary at value base that moves as base + s·d1 + t·d2 under the two independent scalar directions s (outer a) and t (inner b): ∂/∂a = d1, ∂/∂b = d2, all second-and-higher self-derivatives zero (the primary is affine in s, t). This is what a directional bidirectional contraction along arbitrary weight vectors d1, d2 needs — seed every primary i with seed_directional(base_i, d1_i, d2_i), run the program, and read channels()[8] (∂²_a ∂²_b) for Σ_{a,b,c,d} ℓ_{abcd}·d1_a d1_b d2_c d2_d.

pub fn from_channels(c: [f64; 9]) -> Self

Build a nested dual directly from its nine (s-order, t-order) channels, ordered as Self::channels: [v, ∂a, ∂b, ∂aa, ∂ab, ∂bb, ∂aab, ∂abb, ∂aabb]. The inverse of Self::channels. Used to assemble the result of a channel-space operation (e.g. a moment-recurrence residual term) back into a Dual22.

pub fn channels(&self) -> [f64; 9]

The nine channels this nested dual represents, keyed to the two-primary crate::jet_tower::Tower4 indices 0 (outer a) and 1 (inner b): (value, ∂a, ∂b, ∂aa, ∂ab, ∂bb, ∂aab, ∂abb, ∂aabb).

Trait Implementations

impl<S: Clone + JetField> Clone for Dual2<S>

fn clone(&self) -> Dual2<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Copy + JetField> Copy for Dual2<S>

impl<S: Debug + JetField> Debug for Dual2<S>

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

Formats the value using the given formatter.

impl<S: JetField> JetField for Dual2<S>

fn value(&self) -> f64

The real value channel (recurses through any nesting to the f64 leaf).

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

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

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

fn neg(&self) -> Self

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

Multiply every channel by a plain f64.

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

Faà di Bruno composition f ∘ self given the OUTER real function’s derivative stack d = [f(u), f′(u), f″(u), f‴(u), f⁗(u)] evaluated at u = self.value() — the identical [f64; 5] stack shape crate::jet_tower::Tower4::compose_unary consumes.

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

A constant carrying THIS element’s shape: real value v, every derivative channel zero.

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

self with its real value channel replaced by v, every derivative channel untouched.

impl<S: JetFieldConst> JetFieldConst for Dual2<S>

fn from_f64(x: f64) -> Self

A constant field element with value x and every derivative channel zero.

impl<S, const K: usize> JetScalar<K> for Dual2<S>

where S: JetScalar<K>,

Lift a fixed-width primary jet through an independent second-order direction. Primary variables live in the inner scalar; constructing one must not seed the outer direction, which is reserved for a family or hyperparameter derivative selected by the caller.

fn constant(c: f64) -> Self

A constant: value c, every derivative channel zero.

fn variable(x: f64, axis: usize) -> Self

The seeded variable p_axis at value x: unit first derivative in slot axis, all higher channels zero. (The nilpotent / cross channels of the directional scalars are seeded zero — callers set ε/δ directions through the scalar-specific OneSeed::seed_direction / TwoSeed::seed.)

fn symmetric_quadratic_form<C: SymmetricQuadraticCoefficients>( inputs: &[Self], coefficients: &C, ) -> Self

Evaluate inputs' A inputs from one universal semantic primitive. Order-specific scalars may lower the mechanically derived channels directly; the default is the exact scalar program over mul/add/scale.

fn linear_combination(inputs: &[Self], weights: &[f64]) -> 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]]) -> 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 the affine map u = input_scale * self + input_shift.

fn affine_composed_sum( inputs: &[Self], input_scales: &[f64], derivative_stacks: &[[f64; 5]], ) -> 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], ) -> Self

Evaluate Σ_i f_i(input_scale_i · (left_i · right + addend_scale_i · addend)) from the certified derivative stack of each f_i. The shared operands make expression-level common subexpressions explicit, so optimized backends apply their inherited derivative channels once. Expression arity is part of the type, and borrowed operands never copy a full tower. An exact-zero addend scale (either sign of IEEE zero) removes that addend from the corresponding term entirely.

fn compose_unary_with(&self, stack_fn: impl Fn(f64) -> [f64; 5]) -> Self

Compose with a unary special-function whose derivative stack is built from the scalar base value through stack_fn. This evaluates stack_fn(self.value()) once and forwards to compose_unary, so it is bit-identical to the explicit self.compose_unary(stack_fn(self.value())) form.

fn exp(&self) -> Self

e^self. Convenience for tame arguments (see module stability note).

fn sqrt(&self) -> Self

√self. Caller guarantees positivity.

fn ln(&self) -> Self

ln(self). Caller guarantees positivity. Same derivative stack crate::jet_tower::Tower4::ln uses, so any program written over both matches term-for-term.

fn recip(&self) -> Self

1/self.

fn powf(&self, a: f64) -> Self

self^a for real exponent a. Caller guarantees a positive base. Mirrors crate::jet_tower::Tower4::powf (falling-factorial stack).

fn ln_gamma(&self) -> Self

ln Γ(self). Caller guarantees a positive argument. Uses the SAME hand-certified derivative stack crate::jet_tower::Tower4::ln_gamma consumes (crate::jet_tower::ln_gamma_derivative_stack), so any program written over both matches term-for-term.

fn digamma(&self) -> Self

ψ(self) = d/dx ln Γ(x) (digamma). Caller guarantees a positive argument. Same hand-certified stack crate::jet_tower::digamma_derivative_stack.