Struct ConstantAdjoint 

pub struct ConstantAdjoint<N, T> {
    pub node: N,
    pub target: T,
}

Source node for the adjoint of constants.

Fields

node: N

The original source Node.

target: T

The Identifier associated with the adjoint target.

Trait Implementations

impl<N: Clone, T: Clone> Clone for ConstantAdjoint<N, T>

fn clone(&self) -> ConstantAdjoint<N, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N, T, A> Contains<A> for ConstantAdjoint<N, T>

where N: Contains<A>, T: Identifier + PartialEq<A>, A: Identifier,

fn contains(&self, ident: A) -> bool

Returns true if the identifier is present in the expression.

impl<N: Debug, T: Debug> Debug for ConstantAdjoint<N, T>

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

Formats the value using the given formatter.

impl<N, T> Display for ConstantAdjoint<N, T>

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

Formats the value using the given formatter.

impl<N, T, C, F, SN, CN, ST, CT, SA, CA> Function<C> for ConstantAdjoint<N, T>

where F: Scalar, SN: Concat<ST, Shape = SA>, ST: Shape, SA: Shape, CN: Class<SN>, CT: Class<ST>, CA: Class<SA>, Prec: Precedence<CN, CT, Class = CA>, N: Function<C>, N::Value: Buffer<Field = F, Shape = SN, Class = CN>, T: Identifier, C: Read<T>, C::Buffer: Buffer<Field = F, Shape = ST, Class = CT>, <CA as Class<SA>>::Buffer<F>: Buffer<Shape = SA>,

type Error = BinaryError<<N as Function<C>>::Error, SourceError<T>, NoError>

The error type of the function.

type Value = <CA as Class<SA>>::Buffer<F>

The codomain of the function.

fn evaluate<CR: AsRef<C>>(&self, ctx: CR) -> Result<Self::Value, Self::Error>

Evaluate the function and return its Value.

fn evaluate_spec<CR: AsRef<C>>( &self, ctx: CR, ) -> Result<Spec<Self::Value>, Self::Error>

Evaluate the function and return its lifted Value.

fn evaluate_shape<CR: AsRef<C>>(&self, ctx: CR) -> Result<SA, Self::Error>

Evaluate the function and return the shape of the Value.

impl<N: Node, T> Node for ConstantAdjoint<N, T>

fn add<N: Node>(self, other: N) -> Add<Self, N>

where Self: Sized,

fn sub<N: Node>(self, other: N) -> Sub<Self, N>

where Self: Sized,

fn mul<N: Node>(self, other: N) -> Mul<Self, N>

where Self: Sized,

fn div<N: Node>(self, other: N) -> Div<Self, N>

where Self: Sized,

fn dot<N: Node>(self, other: N) -> TensorDot<Self, N>

where Self: Sized,

fn abs(self) -> Abs<Self>

where Self: Sized,

fn neg(self) -> Negate<Self>

where Self: Sized,

fn pow<P>(self, power: P) -> Power<Self, P>

where Self: Sized,

fn ln(self) -> Ln<Self>

where Self: Sized,

fn squared(self) -> Square<Self>

where Self: Sized,

fn sum(self) -> Sum<Self>

where Self: Sized,

fn sigmoid(self) -> Sigmoid<Self>

where Self: Sized,

impl<N: PartialEq, T: PartialEq> PartialEq for ConstantAdjoint<N, T>

fn eq(&self, other: &ConstantAdjoint<N, T>) -> 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<N: Node, T> ToExpr for ConstantAdjoint<N, T>

fn to_expr(&self) -> Expr

Convert the node to an expression string.

impl<N: Copy, T: Copy> Copy for ConstantAdjoint<N, T>

impl<N: Eq, T: Eq> Eq for ConstantAdjoint<N, T>

impl<N, T> StructuralPartialEq for ConstantAdjoint<N, T>