Trait Differentiable 

pub trait Differentiable<R: Value>: Operation<R> {
    type Diff: Operation<R>;

    // Required methods
    fn auto_diff_for<R1: Clone>(
        &self,
        var: Variable<R1>,
        var_trace: &mut HashMap<String, Vec<String>>,
    ) -> Self::Diff;
    fn contains_var<R1: Clone>(&self, var: Variable<R1>) -> bool;
}

Required Associated Types

type Diff: Operation<R>

Required Methods

fn auto_diff_for<R1: Clone>( &self, var: Variable<R1>, var_trace: &mut HashMap<String, Vec<String>>, ) -> Self::Diff

fn contains_var<R1: Clone>(&self, var: Variable<R1>) -> bool

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.

Implementors

impl Differentiable<Void> for Noop

type Diff = Noop

impl<C: Computable> Differentiable<C> for C

type Diff = C

impl<R1: Value, R2: Value, A: Differentiable<R1>, B: Differentiable<R2>> Differentiable<R1> for InstructionList<R1, R2, A, B>

type Diff = InstructionList<R1, R2, Either<<A as Differentiable<R1>>::Diff, A>, Either<<B as Differentiable<R2>>::Diff, B>>

impl<R: Calculatable, LEFT: Differentiable<R>, RIGHT: Differentiable<R>> Differentiable<R> for Add<R, LEFT, RIGHT>

type Diff = OperationWrapper<R, Add<R, <LEFT as Differentiable<R>>::Diff, <RIGHT as Differentiable<R>>::Diff>>

impl<R: Calculatable, LEFT: Differentiable<R>, RIGHT: Differentiable<R>> Differentiable<R> for Divide<R, LEFT, RIGHT>

type Diff = OperationWrapper<R, Divide<R, OperationWrapper<R, Subtract<R, OperationWrapper<R, Multiply<R, <LEFT as Differentiable<R>>::Diff, RIGHT>>, OperationWrapper<R, Multiply<R, LEFT, <RIGHT as Differentiable<R>>::Diff>>>>, OperationWrapper<R, Multiply<R, RIGHT, RIGHT>>>>

impl<R: Calculatable, LEFT: Differentiable<R>, RIGHT: Differentiable<R>> Differentiable<R> for Multiply<R, LEFT, RIGHT>

type Diff = OperationWrapper<R, Add<R, OperationWrapper<R, Multiply<R, LEFT, <RIGHT as Differentiable<R>>::Diff>>, OperationWrapper<R, Multiply<R, <LEFT as Differentiable<R>>::Diff, RIGHT>>>>

impl<R: Calculatable, LEFT: Differentiable<R>, RIGHT: Differentiable<R>> Differentiable<R> for Subtract<R, LEFT, RIGHT>

type Diff = OperationWrapper<R, Subtract<R, <LEFT as Differentiable<R>>::Diff, <RIGHT as Differentiable<R>>::Diff>>

impl<R: Computable> Differentiable<R> for Get<R>

type Diff = Either<OperationWrapper<R, Get<R>>, R>

impl<R: Computable> Differentiable<R> for Variable<R>

type Diff = Either<Variable<R>, R>

impl<R: Computable, G: GetAndSetable<R>, O: Differentiable<R>> Differentiable<Void> for Set<R, G, O>

type Diff = OperationWrapper<Void, Set<R, G, <O as Differentiable<R>>::Diff>>

impl<R: Computable, INPUTS: FunctionInputs, CALLINPUTS: CallInputs + CallMatchFunctionInputs<INPUTS> + DiffableFunctionInputs<R, INPUTS>, A: Differentiable<R>> Differentiable<R> for Call<R, INPUTS, CALLINPUTS, A>

type Diff = Either<<CALLINPUTS as DiffableFunctionInputs<R, INPUTS>>::Diff<A>, Call<R, INPUTS, CALLINPUTS, A>>

impl<R: Computable, ITERABLE: Iterable<R>, A: Differentiable<Void>, B: Differentiable<Void>> Differentiable<Void> for ForEach<R, ITERABLE, A, B>

type Diff = ForEach<R, ITERABLE, Either<<A as Differentiable<Void>>::Diff, A>, Either<<B as Differentiable<Void>>::Diff, B>>

impl<R: Computable, O: Differentiable<R>> Differentiable<Void> for Assign<R, O>

type Diff = OperationWrapper<Void, Assign<R, <O as Differentiable<R>>::Diff>>

impl<R: Computable, T: IndexAble, O: Differentiable<u32>> Differentiable<R> for Index<R, T, O>

type Diff = R

impl<R: Value, CONDITION: Operation<bool>, A: Differentiable<R>, B: Differentiable<Void>, C: Differentiable<R>, D: Differentiable<Void>> Differentiable<R> for IfElse<R, CONDITION, A, B, C, D>

type Diff = IfElse<R, CONDITION, Either<<A as Differentiable<R>>::Diff, A>, Either<<B as Differentiable<Void>>::Diff, B>, Either<<C as Differentiable<R>>::Diff, C>, Either<<D as Differentiable<Void>>::Diff, D>>

impl<R: Value, INPUTS: FunctionInputs, A: Differentiable<R>> Differentiable<R> for Function<R, INPUTS, A>

type Diff = Function<R, INPUTS, <A as Differentiable<R>>::Diff>

impl<R: Value, O: Differentiable<R>> Differentiable<R> for Returns<R, O>

type Diff = Returns<R, <O as Differentiable<R>>::Diff>

impl<R: Value, O: Differentiable<R>> Differentiable<R> for OperationWrapper<R, O>

type Diff = <O as Differentiable<R>>::Diff

impl<R: Value, R2: Value, A: Differentiable<R>, B: Differentiable<R2>> Differentiable<R> for Scope<R, R, R2, A, B>

type Diff = Scope<R, R, R2, Either<<A as Differentiable<R>>::Diff, A>, Either<<B as Differentiable<R2>>::Diff, B>>