Struct Dual 

pub struct Dual<T> { /* private fields */ }

Dual number for forward-mode automatic differentiation

A dual number represents both a value and its derivative: f(x) + f'(x)ε where ε² = 0. This enables exact derivative computation through operator overloading and the chain rule.

Type Parameters

• T - The numeric type (typically f32 or f64)

Examples

use numrs2::autodiff::Dual;

// f(x) = x³ + 2x² - 5x + 1
fn f(x: Dual<f64>) -> Dual<f64> {
    x.pow(3.0) + x.pow(2.0) * 2.0 - x * 5.0 + Dual::constant(1.0)
}

// Compute f(2) and f'(2)
let x = Dual::new(2.0, 1.0);
let result = f(x);
assert_eq!(result.value(), 3.0);   // f(2) = 8 + 8 - 10 + 1 = 7... wait let me recalculate
assert_eq!(result.deriv(), 15.0);  // f'(2) = 3(4) + 2(2)(2) - 5 = 12 + 8 - 5 = 15

Implementations

impl<T: Float> Dual<T>

pub fn new(value: T, deriv: T) -> Self

Create a new dual number with given value and derivative

Arguments

• value - The function value
• deriv - The derivative value

Examples

use numrs2::autodiff::Dual;

// Variable with derivative = 1 (for computing ∂f/∂x)
let x = Dual::new(3.0, 1.0);

// Constant with derivative = 0
let c = Dual::new(5.0, 0.0);

pub fn variable(value: T) -> Self

Create a dual number representing a variable (derivative = 1)

Use this for the input variable with respect to which you want to differentiate.

pub fn constant(value: T) -> Self

Create a dual number representing a constant (derivative = 0)

Use this for constants in expressions.

pub fn value(&self) -> T

Get the value component

pub fn deriv(&self) -> T

Get the derivative component

pub fn pow(&self, n: T) -> Self

Compute power: x^n

pub fn exp(&self) -> Self

Compute exponential: e^x

pub fn ln(&self) -> Self

Compute natural logarithm: ln(x)

pub fn sin(&self) -> Self

Compute sine: sin(x)

pub fn cos(&self) -> Self

Compute cosine: cos(x)

pub fn tan(&self) -> Self

Compute tangent: tan(x)

pub fn sinh(&self) -> Self

Compute hyperbolic sine: sinh(x)

pub fn cosh(&self) -> Self

Compute hyperbolic cosine: cosh(x)

pub fn tanh(&self) -> Self

Compute hyperbolic tangent: tanh(x)

pub fn sqrt(&self) -> Self

Compute square root: √x

pub fn abs(&self) -> Self

Compute absolute value: |x|

Note: The derivative at x=0 is set to 0 by convention.

pub fn sigmoid(&self) -> Self

Compute sigmoid function: 1 / (1 + e^(-x))

pub fn relu(&self) -> Self

Compute ReLU: max(0, x)

Note: The derivative at x=0 is set to 0 by convention.

Trait Implementations

impl<T: Float> Add for Dual<T>

type Output = Dual<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for Dual<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Dual<T>

impl<T: Debug> Debug for Dual<T>

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

Formats the value using the given formatter.

impl<T: Float + Display> Display for Dual<T>

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

Formats the value using the given formatter.

impl<T: Float> Div for Dual<T>

type Output = Dual<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> Mul for Dual<T>

type Output = Dual<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> Neg for Dual<T>

type Output = Dual<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for Dual<T>

fn eq(&self, other: &Dual<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> StructuralPartialEq for Dual<T>

impl<T: Float> Sub for Dual<T>

type Output = Dual<T>

The resulting type after applying the - operator.

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

Performs the - operation.