Struct num_dual::Derivative

pub struct Derivative<T: DualNum<F>, F, R: Dim, C: Dim>(_, _)
where
         DefaultAllocator: Allocator<T, R, C>;

Wrapper struct for a derivative vector or matrix.

Implementations

impl<T: DualNum<F>, F, R: Dim, C: Dim> Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

pub fn new(derivative: Option<OMatrix<T, R, C>>) -> Self

pub fn some(derivative: OMatrix<T, R, C>) -> Self

pub fn none() -> Self

pub fn derivative_generic(r: R, c: C, i: usize) -> Self

pub fn unwrap_generic(self, r: R, c: C) -> OMatrix<T, R, C>

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

impl<T: DualNum<F>, F> Derivative<T, F, U1, U1>

pub fn derivative() -> Self

pub fn unwrap(self) -> T

impl<T: DualNum<F>, F, R: Dim, C: Dim> Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

pub fn tr_mul<R2: Dim, C2: Dim>( &self, rhs: &Derivative<T, F, R2, C2> ) -> Derivative<T, F, C, C2>where DefaultAllocator: Allocator<T, R2, C2> + Allocator<T, C, C2>, ShapeConstraint: SameNumberOfRows<R, R2>,

Trait Implementations

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Add<&'a Derivative<T, F, R, C>> for &'a Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Add<&'a Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the + operator.

fn add(self, rhs: &Derivative<T, F, R, C>) -> Self::Output

Performs the + operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> Add<Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> AddAssign<Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + DualNum<F>, F: Clone, R: Clone + Dim, C: Clone + Dim> Clone for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

fn clone(&self) -> Derivative<T, F, R, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + DualNum<F>, F: Debug, R: Debug + Dim, C: Debug + Dim> Debug for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

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

Formats the value using the given formatter.

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Div<T> for &'a Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> Div<T> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> DivAssign<T> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<'a, 'b, T: DualNum<F>, F, R: Dim, C: Dim, R2: Dim, C2: Dim> Mul<&'b Derivative<T, F, R2, C2>> for &'a Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C> + Allocator<T, R2, C2> + Allocator<T, R, C2>, ShapeConstraint: SameNumberOfRows<C, R2>,

type Output = Derivative<T, F, R, C2>

The resulting type after applying the * operator.

fn mul(self, rhs: &Derivative<T, F, R2, C2>) -> Derivative<T, F, R, C2>

Performs the * operation.

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Mul<T> for &'a Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> Mul<T> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> MulAssign<T> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Neg for &'a Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> Neg for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq + DualNum<F>, F: PartialEq, R: PartialEq + Dim, C: PartialEq + Dim> PartialEq<Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

fn eq(&self, other: &Derivative<T, F, R, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T, R: Dim, C: Dim> SimdValue for Derivative<T, T::Element, R, C>where DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>, T: DualNum<T::Element> + SimdValue + Scalar, T::Element: DualNum<T::Element> + Scalar + Zero,

type Element = Derivative<<T as SimdValue>::Element, <T as SimdValue>::Element, R, C>

The type of the elements of each lane of this SIMD value.

type SimdBool = <T as SimdValue>::SimdBool

Type of the result of comparing two SIMD values like self.

fn lanes() -> usize

The number of lanes of this SIMD value.

fn splat(val: Self::Element) -> Self

Initializes an SIMD value with each lanes set to val.

fn extract(&self, i: usize) -> Self::Element

Extracts the i-th lane of self.

unsafe fn extract_unchecked(&self, i: usize) -> Self::Element

Extracts the i-th lane of self without bound-checking.

fn replace(&mut self, i: usize, val: Self::Element)

Replaces the i-th lane of self by val.

unsafe fn replace_unchecked(&mut self, i: usize, val: Self::Element)

Replaces the i-th lane of self by val without bound-checking.

fn select(self, cond: Self::SimdBool, other: Self) -> Self

Merges self and other depending on the lanes of cond.

fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Selfwhere Self: Clone,

Applies a function to each lane of self.

fn zip_map_lanes( self, b: Self, f: impl Fn(Self::Element, Self::Element) -> Self::Element ) -> Selfwhere Self: Clone,

Applies a function to each lane of self paired with the corresponding lane of b.

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Sub<&'a Derivative<T, F, R, C>> for &'a Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T: DualNum<F>, F, R: Dim, C: Dim> Sub<&'a Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the - operator.

fn sub(self, rhs: &Derivative<T, F, R, C>) -> Self::Output

Performs the - operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> Sub<Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

type Output = Derivative<T, F, R, C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: DualNum<F>, F, R: Dim, C: Dim> SubAssign<Derivative<T, F, R, C>> for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<TSuper, FSuper, T, F, R: Dim, C: Dim> SubsetOf<Derivative<TSuper, FSuper, R, C>> for Derivative<T, F, R, C>where TSuper: DualNum<FSuper> + SupersetOf<T>, T: DualNum<F>, DefaultAllocator: Allocator<T, R, C> + Allocator<TSuper, R, C>,

fn to_superset(&self) -> Derivative<TSuper, FSuper, R, C>

The inclusion map: converts self to the equivalent element of its superset.

fn from_superset(element: &Derivative<TSuper, FSuper, R, C>) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

fn from_superset_unchecked(element: &Derivative<TSuper, FSuper, R, C>) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn is_in_subset(element: &Derivative<TSuper, FSuper, R, C>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

impl<T: DualNum<F> + Copy, F: Copy, const R: usize, const C: usize> Copy for Derivative<T, F, Const<R>, Const<C>>

impl<T: Eq + DualNum<F>, F: Eq, R: Eq + Dim, C: Eq + Dim> Eq for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

impl<T: DualNum<F>, F, R: Dim, C: Dim> StructuralEq for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,

impl<T: DualNum<F>, F, R: Dim, C: Dim> StructuralPartialEq for Derivative<T, F, R, C>where DefaultAllocator: Allocator<T, R, C>,