Struct Constant 

pub struct Constant<S: Shaped + IntoSpec>(pub S);

Source node for numerical constants.

This node implements both Function and Differentiable. The former simply returns the wrapped value, and the latter returns an instance of ConstantAdjoint that handles (empty) buffer shaping.

Examples

let cns = Constant([10.0, 10.0]);
let jac = cns.adjoint(X);

assert_eq!(cns.evaluate(ctx!{X = [1.0, 2.0]}).unwrap(), [10.0, 10.0]);
assert_eq!(jac.evaluate(ctx!{X = [1.0, 2.0]}).unwrap(), [
    [0.0, 0.0],
    [0.0, 0.0]
]);

Tuple Fields

0: S

Trait Implementations

impl<S: Clone + Shaped + IntoSpec> Clone for Constant<S>

fn clone(&self) -> Constant<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Contains<T> for Constant<S>

where T: Identifier, S: Shaped + IntoSpec,

fn contains(&self, _: T) -> bool

Returns true if the identifier is present in the expression.

impl<B> Debug for Constant<B>

where B: Buffer + Debug, B::Field: Debug, B::Shape: Debug,

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

Formats the value using the given formatter.

impl<T, B> Differentiable<T> for Constant<B>

where T: Identifier, B: Buffer, FieldOf<B>: Zero,

type Adjoint = ConstantAdjoint<Constant<B>, T>

The adjoint operator; i.e. the gradient.

fn adjoint(&self, ident: T) -> Self::Adjoint

Transform the node into its Adjoint operator tree.

fn evaluate_adjoint<C: Context, CR: AsRef<C>>( &self, target: T, ctx: CR, ) -> AegirResult<Self::Adjoint, C>

where Self: Function<C>, Self::Adjoint: Function<C>,

Helper method that computes the adjoint and evaluates its value.

fn evaluate_dual<C: Context, CR: AsRef<C>>( &self, target: T, ctx: CR, ) -> Result<DualOf<Self, C, T>, BinaryError<Self::Error, <AdjointOf<Self, T> as Function<C>>::Error, NoError>>

where Self: Function<C>, Self::Adjoint: Function<C>,

Helper method that evaluates the function and its adjoint, wrapping up in a Dual.

impl<B: Buffer + ToString> Display for Constant<B>

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

Formats the value using the given formatter.

impl<C, S> Function<C> for Constant<S>

where C: Context, S: Clone + Shaped + IntoSpec, S::Buffer: Shaped<Shape = S::Shape>,

type Error = SourceError<()>

The error type of the function.

type Value = <S as IntoSpec>::Buffer

The codomain of the function.

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

Evaluate the function and return its Value.

fn evaluate_spec<CR: AsRef<C>>( &self, _: CR, ) -> Result<Spec<S::Buffer>, Self::Error>

Evaluate the function and return its lifted Value.

fn evaluate_shape<CR: AsRef<C>>(&self, _: CR) -> Result<S::Shape, Self::Error>

Evaluate the function and return the shape of the Value.

impl<S: Shaped + IntoSpec> Node for Constant<S>

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<S: PartialEq + Shaped + IntoSpec> PartialEq for Constant<S>

fn eq(&self, other: &Constant<S>) -> 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<B: Buffer + ToString> ToExpr for Constant<B>

fn to_expr(&self) -> Expr

Convert the node to an expression string.

impl<S: Copy + Shaped + IntoSpec> Copy for Constant<S>

impl<S: Eq + Shaped + IntoSpec> Eq for Constant<S>

impl<S: Shaped + IntoSpec> StructuralPartialEq for Constant<S>