Trait Mappable 

pub trait Mappable<D> {
    type Output<O>;

    // Required method
    fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>;
}

Trait for structs used as an output of functions for which derivatives are calculated.

The main intention is to generalize the calculation of derivatives to fallible functions, but other use cases might also appear in the future.

Required Associated Types

type Output<O>

Required Methods

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Mappable<f32> for f32

type Output<O> = O

fn map_dual<M: FnOnce(f32) -> O, O>(self, f: M) -> Self::Output<O>

impl Mappable<f64> for f64

type Output<O> = O

fn map_dual<M: FnOnce(f64) -> O, O>(self, f: M) -> Self::Output<O>

impl<D> Mappable<D> for ()

type Output<O> = ()

fn map_dual<M: FnOnce(D) -> O, O>(self, _: M)

impl<D, T1: Mappable<D>, T2: Mappable<D>> Mappable<D> for (T1, T2)

type Output<O> = (<T1 as Mappable<D>>::Output<O>, <T2 as Mappable<D>>::Output<O>)

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T1: Mappable<D>, T2: Mappable<D>, T3: Mappable<D>> Mappable<D> for (T1, T2, T3)

type Output<O> = (<T1 as Mappable<D>>::Output<O>, <T2 as Mappable<D>>::Output<O>, <T3 as Mappable<D>>::Output<O>)

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T1: Mappable<D>, T2: Mappable<D>, T3: Mappable<D>, T4: Mappable<D>> Mappable<D> for (T1, T2, T3, T4)

type Output<O> = (<T1 as Mappable<D>>::Output<O>, <T2 as Mappable<D>>::Output<O>, <T3 as Mappable<D>>::Output<O>, <T4 as Mappable<D>>::Output<O>)

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T1: Mappable<D>, T2: Mappable<D>, T3: Mappable<D>, T4: Mappable<D>, T5: Mappable<D>> Mappable<D> for (T1, T2, T3, T4, T5)

type Output<O> = (<T1 as Mappable<D>>::Output<O>, <T2 as Mappable<D>>::Output<O>, <T3 as Mappable<D>>::Output<O>, <T4 as Mappable<D>>::Output<O>, <T5 as Mappable<D>>::Output<O>)

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T: Mappable<D>> Mappable<D> for Option<T>

type Output<O> = Option<<T as Mappable<D>>::Output<O>>

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T: Mappable<D>> Mappable<D> for Vec<T>

type Output<O> = Vec<<T as Mappable<D>>::Output<O>>

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T: Mappable<D>, E> Mappable<D> for Result<T, E>

type Output<O> = Result<<T as Mappable<D>>::Output<O>, E>

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T: Mappable<D>, K: Eq + Hash> Mappable<D> for HashMap<K, T>

type Output<O> = HashMap<K, <T as Mappable<D>>::Output<O>>

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D, T: Mappable<D>, const N: usize> Mappable<D> for [T; N]

type Output<O> = [<T as Mappable<D>>::Output<O>; N]

fn map_dual<M: Fn(D) -> O, O>(self, f: M) -> Self::Output<O>

impl<D: Scalar, R: Dim, C: Dim> Mappable<Matrix<D, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<D>>> for OMatrix<D, R, C>

where DefaultAllocator: Allocator<R, C>,

type Output<O> = O

fn map_dual<M: Fn(Self) -> O, O>(self, f: M) -> O

Implementors

impl<T: DualNum<F>, F> Mappable<Dual2<T, F>> for Dual2<T, F>

type Output<O> = O

impl<T: DualNum<F>, F> Mappable<Dual3<T, F>> for Dual3<T, F>

type Output<O> = O

impl<T: DualNum<F>, F> Mappable<Dual<T, F>> for Dual<T, F>

type Output<O> = O

impl<T: DualNum<F>, F> Mappable<HyperDual<T, F>> for HyperDual<T, F>

type Output<O> = O

impl<T: DualNum<F>, F> Mappable<HyperHyperDual<T, F>> for HyperHyperDual<T, F>

type Output<O> = O

impl<T: DualNum<F>, F> Mappable<Real<T, F>> for Real<T, F>

type Output<O> = O

impl<T: DualNum<F>, F, D: Dim> Mappable<Dual2Vec<T, F, D>> for Dual2Vec<T, F, D>

where DefaultAllocator: Allocator<U1, D> + Allocator<D, D>,

type Output<O> = O

impl<T: DualNum<F>, F, D: Dim> Mappable<DualVec<T, F, D>> for DualVec<T, F, D>

where DefaultAllocator: Allocator<D>,

type Output<O> = O

impl<T: DualNum<F>, F, M: Dim, N: Dim> Mappable<HyperDualVec<T, F, M, N>> for HyperDualVec<T, F, M, N>

where DefaultAllocator: Allocator<M> + Allocator<M, N> + Allocator<U1, N>,

type Output<O> = O