Struct Dual 

pub struct Dual<F: IntegrateFloat> {
    pub val: F,
    pub der: F,
}

Dual number for forward-mode automatic differentiation

Fields

val: F

The value part

der: F

The derivative part

Implementations

impl<F: IntegrateFloat> Dual<F>

pub fn new(val: F, der: F) -> Self

Create a new dual number

pub fn constant(val: F) -> Self

Create a constant dual number (zero derivative)

pub fn variable(val: F) -> Self

Create a variable dual number (unit derivative)

pub fn value(&self) -> F

Extract the value

pub fn derivative(&self) -> F

Extract the derivative

pub fn sin(&self) -> Self

Compute sin(x)

pub fn cos(&self) -> Self

Compute cos(x)

pub fn exp(&self) -> Self

Compute exp(x)

pub fn ln(&self) -> Self

Compute ln(x)

pub fn sqrt(&self) -> Self

Compute sqrt(x)

pub fn powf(&self, n: F) -> Self

Compute x^y for constant y

pub fn abs(&self) -> Self

Compute abs(x)

pub fn tan(&self) -> Self

Compute tan(x)

pub fn tanh(&self) -> Self

Compute tanh(x)

pub fn sinh(&self) -> Self

Compute sinh(x)

pub fn cosh(&self) -> Self

Compute cosh(x)

pub fn atan(&self) -> Self

Compute atan(x)

pub fn asin(&self) -> Self

Compute asin(x)

pub fn acos(&self) -> Self

Compute acos(x)

pub fn atan2(&self, x: Self) -> Self

Compute atan2(y, x)

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

Compute max(self, other)

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

Compute min(self, other)

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

Compute x^y where both x and y are dual numbers

Trait Implementations

impl<F: IntegrateFloat> Add<F> for Dual<F>

type Output = Dual<F>

The resulting type after applying the + operator.

fn add(self, scalar: F) -> Self

Performs the + operation.

impl<F: IntegrateFloat> Add for Dual<F>

type Output = Dual<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Clone + IntegrateFloat> Clone for Dual<F>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + IntegrateFloat> Debug for Dual<F>

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

Formats the value using the given formatter.

impl<F: IntegrateFloat> Display for Dual<F>

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

Formats the value using the given formatter.

impl<F: IntegrateFloat> Div<F> for Dual<F>

type Output = Dual<F>

The resulting type after applying the / operator.

fn div(self, scalar: F) -> Self

Performs the / operation.

impl<F: IntegrateFloat> Div for Dual<F>

type Output = Dual<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: IntegrateFloat> Mul<F> for Dual<F>

type Output = Dual<F>

The resulting type after applying the * operator.

fn mul(self, scalar: F) -> Self

Performs the * operation.

impl<F: IntegrateFloat> Mul for Dual<F>

type Output = Dual<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: IntegrateFloat> Neg for Dual<F>

type Output = Dual<F>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<F: PartialEq + IntegrateFloat> PartialEq for Dual<F>

fn eq(&self, other: &Dual<F>) -> 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<F: IntegrateFloat> Sub<F> for Dual<F>

type Output = Dual<F>

The resulting type after applying the - operator.

fn sub(self, scalar: F) -> Self

Performs the - operation.

impl<F: IntegrateFloat> Sub for Dual<F>

type Output = Dual<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Copy + IntegrateFloat> Copy for Dual<F>

impl<F: IntegrateFloat> StructuralPartialEq for Dual<F>