Struct HyperDual 

pub struct HyperDual<T: Numeric> {
    pub real: T,
    pub eps1: T,
    pub eps2: T,
    pub eps1eps2: T,
}

A hyper-dual number real + eps1·ε₁ + eps2·ε₂ + eps1eps2·ε₁ε₂, where ε₁² = ε₂² = 0.

After evaluating a function, real holds the value, eps1/eps2 hold the first derivatives along each seeded direction, and eps1eps2 holds the second (mixed) derivative.

Fields

real: T

The value, f.

eps1: T

First derivative along direction 1.

eps2: T

First derivative along direction 2.

eps1eps2: T

Second derivative across the two directions.

Implementations

impl<T: Numeric> HyperDual<T>

pub fn new(real: T, eps1: T, eps2: T, eps1eps2: T) -> Self

A hyper-dual number with explicit components.

pub fn constant(real: T) -> Self

A constant, whose derivatives are all zero.

pub fn variable(real: T) -> Self

The independent variable, seeded along both directions to read f, f', and f'' of a single-variable function. For a mixed partial, seed two inputs on separate directions with new(xᵢ, 1, 0, 0) and new(xⱼ, 0, 1, 0).

Trait Implementations

impl<T: Numeric> Add for HyperDual<T>

type Output = HyperDual<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T: Numeric> AddAssign for HyperDual<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + Numeric> Clone for HyperDual<T>

fn clone(&self) -> HyperDual<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Numeric> Copy for HyperDual<T>

impl<T: Debug + Numeric> Debug for HyperDual<T>

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

Formats the value using the given formatter.

impl<T: Numeric> Div for HyperDual<T>

fn div(self, rhs: Self) -> Self

self · (1/rhs). A zero divisor yields inf/NaN, as with plain floats.

type Output = HyperDual<T>

The resulting type after applying the / operator.

impl<T: Numeric> DivAssign for HyperDual<T>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T: Numeric> Mul for HyperDual<T>

fn mul(self, rhs: Self) -> Self

Second-order product rule: each derivative part collects the cross terms that survive ε₁² = ε₂² = 0.

type Output = HyperDual<T>

The resulting type after applying the * operator.

impl<T: Numeric> MulAssign for HyperDual<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Numeric> Neg for HyperDual<T>

type Output = HyperDual<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Numeric> Numeric for HyperDual<T>

fn abs(self) -> Self

Derivative of |x| is its sign (the subgradient at zero is +1); its second derivative is zero.

fn sqrt(self) -> Self

At real == 0 the derivatives are unbounded and become inf/NaN.

fn ln(self) -> Self

Defined for real > 0; at 0 the value is -inf and the derivatives unbounded.

fn atan2(self, other: Self) -> Self

Four-quadrant arctangent carried to second order. With Y = self.real, X = other.real, r² = X² + Y², the partials are f_Y = X/r², f_X = −Y/r², f_YY = −2XY/r⁴, f_XX = 2XY/r⁴, f_XY = (Y² − X²)/r⁴. The r² denominator is nonzero off the origin, so the x = 0 axis is handled; only X = Y = 0 degenerates, as for float atan2.

fn copysign(self, sign: Self) -> Self

Magnitude of self with the sign of sign: a linear scaling by ±1, so it rides the univariate chain helper with slope s and zero curvature.

fn floor(self) -> Self

Largest integer <= self; the derivatives of a step function are zero.

fn is_nan(self) -> bool

Reflects the real part only; the derivatives are not inspected.

fn is_finite(self) -> bool

Reflects the real part only; a finite value can still carry a non-finite derivative (e.g. from sqrt(0) or ln(0)).

const ZERO: Self

The value 0.

const ONE: Self

The value 1.

const TWO: Self

The value 2.

const HALF: Self

The value 0.5.

const PI: Self

Archimedes’ constant, π.

const EPSILON: Self

The difference between 1 and the next larger representable value.

const NAN: Self

Not a Number.

const INFINITY: Self

Positive infinity.

const NEG_INFINITY: Self

Negative infinity.

const MAX: Self

The largest finite value.

const MIN_POSITIVE: Self

The smallest positive normal value.

fn from_f64(value: f64) -> Self

Converts from f64, narrowing if necessary. Used for table values and literals.

fn from_u64(value: u64) -> Self

Converts from u64, e.g. an iteration count.

fn from_usize(value: usize) -> Self

Converts from usize, e.g. a point or variable count.

fn sin(self) -> Self

Sine, with self in radians.

fn cos(self) -> Self

Cosine, with self in radians.

fn tan(self) -> Self

Tangent, with self in radians.

fn exp(self) -> Self

e raised to the power self.

fn signum(self) -> Self

Sign of self: 1 for positive, -1 for negative, 0 at zero.

fn max(self, other: Self) -> Self

The larger of self and other, compared with >.

fn min(self, other: Self) -> Self

The smaller of self and other, compared with <.

fn atan(self) -> Self

Arctangent, in radians.

fn asin(self) -> Self

Arcsine, in radians, for self in [-1, 1].

fn acos(self) -> Self

Arccosine, in radians, for self in [-1, 1].

fn sinh(self) -> Self

Hyperbolic sine.

fn cosh(self) -> Self

Hyperbolic cosine.

fn tanh(self) -> Self

Hyperbolic tangent.

fn hypot(self, other: Self) -> Self

Euclidean distance √(self² + other²), scaled to avoid overflow and underflow.

fn powf(self, n: Self) -> Self

self raised to a floating-point power, via exp(n · ln self). Defined for self > 0; the f32/f64 impls override for negative bases and edge cases.

fn mul_add(self, a: Self, b: Self) -> Self

self * a + b. The f32/f64 impls fuse the operation for extra precision.

fn recip(self) -> Self

The reciprocal 1 / self.

fn powi(self, n: i32) -> Self

self raised to an integer power, by exponentiation-by-squaring.

impl<T: Numeric> PartialEq for HyperDual<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: Numeric> PartialOrd for HyperDual<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Numeric + Primal> Primal for HyperDual<T>

fn to_f64(&self) -> f64

Returns the value as an f64 (the primal part, for autodiff scalars).

fn to_f32(&self) -> f32

Returns the value as an f32 (the primal part, for autodiff scalars).

impl<T: Numeric> Sub for HyperDual<T>

type Output = HyperDual<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T: Numeric> SubAssign for HyperDual<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.