Struct Dual 

pub struct Dual<V, A = V> {
    pub value: V,
    pub adjoint: A,
}

Dual variable for forward-mode autodifferentiation over aegir buffers.

This struct can be used as a simple container for a value and its adjoint (as we do within this crate). Alternatively, it can be used as a lightweight implementation of the “augmented algebra” commonly found in autodifferentiation libraries. It is by no means exhaustive, but may come in handy for some applications.

Fields

value: V

The value associated with the dual number.

adjoint: A

The gradient/adjoint associated with the dual number.

Implementations

impl<F: Scalar, B: Buffer<Field = F>> Dual<B>

pub fn variable(buffer: B) -> Dual<B>

Returns a dual number with adjoint initialised as ones.

pub fn constant(buffer: B) -> Dual<B>

Returns a dual number with adjoint initialised as zeroes.

impl<V, A: Buffer> Dual<V, A>

where FieldOf<A>: Neg<Output = FieldOf<A>>,

pub fn conj(self) -> Dual<V, A>

Returns the dual conjugate of self.

Trait Implementations

impl<'a, V, A> Add<&'a Dual<V, A>> for Dual<V, A>

where V: Buffer + Add<&'a V>, A: Buffer + Add<&'a A>,

type Output = Dual<<V as Add<&'a V>>::Output, <A as Add<&'a A>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Dual<V, A>) -> Dual<V::Output, A::Output>

Performs the + operation.

impl<'a, V, A> Add<&'a V> for Dual<V, A>

where V: Buffer + Add<&'a V>,

type Output = Dual<<V as Add<&'a V>>::Output, A>

The resulting type after applying the + operator.

fn add(self, rhs: &'a V) -> Dual<V::Output, A>

Performs the + operation.

impl<V, A> Add<V> for Dual<V, A>

where V: Buffer + Add<V>,

type Output = Dual<<V as Add>::Output, A>

The resulting type after applying the + operator.

fn add(self, rhs: V) -> Dual<V::Output, A>

Performs the + operation.

impl<V, A> Add for Dual<V, A>

where V: Buffer + Add<V>, A: Buffer + Add<A>,

type Output = Dual<<V as Add>::Output, <A as Add>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Dual<V, A>) -> Dual<V::Output, A::Output>

Performs the + operation.

impl<V: Clone, A: Clone> Clone for Dual<V, A>

fn clone(&self) -> Dual<V, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug, A: Debug> Debug for Dual<V, A>

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

Formats the value using the given formatter.

impl<V, A> From<(V, A)> for Dual<V, A>

fn from((value, adjoint): (V, A)) -> Dual<V, A>

Converts to this type from the input type.

impl<'a, V, A> Mul<&'a Dual<V, A>> for Dual<V, A>

where V: Buffer + Mul<&'a V> + Mul<&'a A>, A: Buffer + Mul<&'a V>, <A as Mul<&'a V>>::Output: Add<<V as Mul<&'a A>>::Output>,

type Output = Dual<<V as Mul<&'a V>>::Output, <<A as Mul<&'a V>>::Output as Add<<V as Mul<&'a A>>::Output>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Dual<V, A>) -> Self::Output

Performs the * operation.

impl<'a, V, A> Mul<&'a V> for Dual<V, A>

where V: Buffer + Mul<&'a V>,

type Output = Dual<<V as Mul<&'a V>>::Output, A>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a V) -> Self::Output

Performs the * operation.

impl<V, A> Mul<V> for Dual<V, A>

where V: Buffer + Mul<V>,

type Output = Dual<<V as Mul>::Output, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<V, A> Mul for Dual<V, A>

where V: Buffer + Mul<V>, A: Buffer + Mul<V>, <A as Mul<V>>::Output: Add<<A as Mul<V>>::Output>,

type Output = Dual<<V as Mul>::Output, <<A as Mul<V>>::Output as Add>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Dual<V, A>) -> Self::Output

Performs the * operation.

impl<V, A> Neg for Dual<V, A>

where V: Buffer + Neg, A: Buffer + Neg,

type Output = Dual<<V as Neg>::Output, <A as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Dual<V::Output, A::Output>

Performs the unary - operation.

impl<V: PartialEq, A: PartialEq> PartialEq for Dual<V, A>

fn eq(&self, other: &Dual<V, A>) -> 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<'a, V, A> Sub<&'a Dual<V, A>> for Dual<V, A>

where V: Buffer + Sub<&'a V>, A: Buffer + Sub<&'a A>,

type Output = Dual<<V as Sub<&'a V>>::Output, <A as Sub<&'a A>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Dual<V, A>) -> Dual<V::Output, A::Output>

Performs the - operation.

impl<'a, V, A> Sub<&'a V> for Dual<V, A>

where V: Buffer + Sub<&'a V>,

type Output = Dual<<V as Sub<&'a V>>::Output, A>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a V) -> Dual<V::Output, A>

Performs the - operation.

impl<V, A> Sub<V> for Dual<V, A>

where V: Buffer + Sub<V>,

type Output = Dual<<V as Sub>::Output, A>

The resulting type after applying the - operator.

fn sub(self, rhs: V) -> Dual<V::Output, A>

Performs the - operation.

impl<V, A> Sub for Dual<V, A>

where V: Buffer + Sub<V>, A: Buffer + Sub<A>,

type Output = Dual<<V as Sub>::Output, <A as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Dual<V, A>) -> Dual<V::Output, A::Output>

Performs the - operation.

impl<V: Copy, A: Copy> Copy for Dual<V, A>

impl<V, A> StructuralPartialEq for Dual<V, A>