Struct DualNumber 

pub struct DualNumber<T>
where
    T: Float,
{
    pub real: T,
    pub dual: T,
}

A dual number for automatic differentiation

Dual numbers enable exact derivative computation using the algebraic property ε² = 0. For a function f(x), evaluating f(x + ε) automatically computes both f(x) and f’(x).

Examples

use amari_dual::DualNumber;

// Create a variable x = 3.0 (with derivative dx/dx = 1.0)
let x = DualNumber::variable(3.0);

// Compute f(x) = x² + 2x + 1
let result = x * x + DualNumber::constant(2.0) * x + DualNumber::constant(1.0);

// result.real = f(3) = 9 + 6 + 1 = 16
// result.dual = f'(3) = 2(3) + 2 = 8
assert_eq!(result.real, 16.0);
assert_eq!(result.dual, 8.0);

Fields

real: T

The real part (function value)

dual: T

The dual part (derivative)

Implementations

impl<T> DualNumber<T>

where T: Float,

pub fn new(real: T, dual: T) -> DualNumber<T>

Create a new dual number

pub fn constant(value: T) -> DualNumber<T>

Create a constant (derivative = 0)

Constants have zero derivative since d/dx(c) = 0.

pub fn variable(value: T) -> DualNumber<T>

Create a variable (derivative = 1)

Variables have unit derivative since d/dx(x) = 1.

pub fn value(&self) -> T

Get the value (real part)

pub fn derivative(&self) -> T

Get the derivative (dual part)

pub fn exp(self) -> DualNumber<T>

Exponential function: exp(a + b·ε) = exp(a) + b·exp(a)·ε

Uses the chain rule: d/dx(e^f) = f’·e^f

pub fn ln(self) -> DualNumber<T>

Natural logarithm: ln(a + b·ε) = ln(a) + (b/a)·ε

Uses the chain rule: d/dx(ln f) = f’/f

pub fn sin(self) -> DualNumber<T>

Sine function: sin(a + b·ε) = sin(a) + b·cos(a)·ε

Uses the chain rule: d/dx(sin f) = f’·cos(f)

pub fn cos(self) -> DualNumber<T>

Cosine function: cos(a + b·ε) = cos(a) - b·sin(a)·ε

Uses the chain rule: d/dx(cos f) = -f’·sin(f)

pub fn tan(self) -> DualNumber<T>

Tangent function: tan(a + b·ε) = tan(a) + b·sec²(a)·ε

Uses the chain rule: d/dx(tan f) = f’·sec²(f) = f’/cos²(f)

pub fn sqrt(self) -> DualNumber<T>

Square root: sqrt(a + b·ε) = sqrt(a) + (b/(2·sqrt(a)))·ε

Uses the chain rule: d/dx(√f) = f’/(2√f)

pub fn powf(self, n: T) -> DualNumber<T>

Power function: (a + b·ε)^n = a^n + n·b·a^(n-1)·ε

Uses the power rule: d/dx(f^n) = n·f’·f^(n-1)

pub fn powi(self, n: i32) -> DualNumber<T>

Integer power function: (a + b·ε)^n = a^n + n·b·a^(n-1)·ε

Uses the power rule: d/dx(f^n) = n·f’·f^(n-1)

pub fn abs(self) -> DualNumber<T>

Absolute value: |a + b·ε| = |a| + b·sign(a)·ε

Derivative is sign(a), undefined at a=0

pub fn sinh(self) -> DualNumber<T>

Hyperbolic sine: sinh(a + b·ε) = sinh(a) + b·cosh(a)·ε

pub fn cosh(self) -> DualNumber<T>

Hyperbolic cosine: cosh(a + b·ε) = cosh(a) + b·sinh(a)·ε

pub fn tanh(self) -> DualNumber<T>

Hyperbolic tangent: tanh(a + b·ε) = tanh(a) + b·sech²(a)·ε

pub fn max(self, other: DualNumber<T>) -> DualNumber<T>

Maximum of two dual numbers (non-differentiable at equality)

pub fn min(self, other: DualNumber<T>) -> DualNumber<T>

Minimum of two dual numbers (non-differentiable at equality)

pub fn sigmoid(self) -> DualNumber<T>

Sigmoid (logistic) function: σ(x) = 1/(1 + e^(-x))

Uses the chain rule: d/dx(σ(f)) = σ(f)·(1 - σ(f))·f’

pub fn apply_with_derivative<F, G>(self, f: F, df: G) -> DualNumber<T>

where F: Fn(T) -> T, G: Fn(T) -> T,

Apply a function with its derivative

This is useful for applying functions where you know both f(x) and f’(x). The chain rule is applied automatically.

Arguments

• f - The function to apply
• df - The derivative of the function

Trait Implementations

impl<T> Add for DualNumber<T>

where T: Float,

type Output = DualNumber<T>

The resulting type after applying the + operator.

fn add(self, other: DualNumber<T>) -> DualNumber<T>

Performs the + operation.

impl<T> Clone for DualNumber<T>

where T: Clone + Float,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for DualNumber<T>

where T: Debug + Float,

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

Formats the value using the given formatter.

impl<T> Display for DualNumber<T>

where T: Float + Display,

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

Formats the value using the given formatter.

impl<T> Div for DualNumber<T>

where T: Float,

type Output = DualNumber<T>

The resulting type after applying the / operator.

fn div(self, other: DualNumber<T>) -> DualNumber<T>

Performs the / operation.

impl<T, const P: usize, const Q: usize, const R: usize> Mul<DualNumber<T>> for DualMultivector<T, P, Q, R>

where T: Float,

type Output = DualMultivector<T, P, Q, R>

The resulting type after applying the * operator.

fn mul(self, scalar: DualNumber<T>) -> DualMultivector<T, P, Q, R>

Performs the * operation.

impl<T> Mul for DualNumber<T>

where T: Float,

type Output = DualNumber<T>

The resulting type after applying the * operator.

fn mul(self, other: DualNumber<T>) -> DualNumber<T>

Performs the * operation.

impl<T> Neg for DualNumber<T>

where T: Float,

type Output = DualNumber<T>

The resulting type after applying the - operator.

fn neg(self) -> DualNumber<T>

Performs the unary - operation.

impl<T> One for DualNumber<T>

where T: Float,

fn one() -> DualNumber<T>

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T> PartialEq for DualNumber<T>

where T: PartialEq + Float,

fn eq(&self, other: &DualNumber<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Sub for DualNumber<T>

where T: Float,

type Output = DualNumber<T>

The resulting type after applying the - operator.

fn sub(self, other: DualNumber<T>) -> DualNumber<T>

Performs the - operation.

impl<T> Zero for DualNumber<T>

where T: Float,

fn zero() -> DualNumber<T>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T> Copy for DualNumber<T>

where T: Copy + Float,

impl<T> StructuralPartialEq for DualNumber<T>

where T: Float,