Enum AdValue 

pub enum AdValue<T> {
    Primal(T),
    Forward {
        primal: T,
        tangent: T,
    },
    Reverse {
        primal: T,
        node: NodeId,
        tape: TapeId,
        tangent: Option<T>,
    },
}

Generic AD value that can wrap any user-defined payload type T.

This is the primary extension point of the crate.

Examples

use ad_tensors_rs::{AdMode, AdValue, NodeId, TapeId};

let primal = AdValue::primal(3.0_f64);
assert_eq!(primal.mode(), AdMode::Primal);

let dual = AdValue::forward(3.0_f64, 1.0_f64);
assert_eq!(dual.mode(), AdMode::Forward);

let tracked = AdValue::reverse(3.0_f64, NodeId(1), TapeId(9), None);
assert_eq!(tracked.mode(), AdMode::Reverse);

Variants

Primal(T)

Primal-only value.

Forward

Forward-mode value and tangent.

Fields

primal: T

tangent: T

Reverse

Reverse-mode value with graph metadata.

Fields

primal: T

node: NodeId

tape: TapeId

tangent: Option<T>

Implementations

impl<T> AdValue<T>

pub fn primal(value: T) -> Self

Creates a primal-only value.

Examples

use ad_tensors_rs::AdValue;

let x = AdValue::primal(2_i32);
assert!(matches!(x, AdValue::Primal(2)));

pub fn forward(primal: T, tangent: T) -> Self

Creates a forward-mode value.

Examples

use ad_tensors_rs::AdValue;

let x = AdValue::forward(2.0_f64, 1.0_f64);
assert!(matches!(x, AdValue::Forward { .. }));

pub fn reverse( primal: T, node: NodeId, tape: TapeId, tangent: Option<T>, ) -> Self

Creates a reverse-mode value.

Examples

use ad_tensors_rs::{AdValue, NodeId, TapeId};

let x = AdValue::reverse(2.0_f64, NodeId(3), TapeId(5), Some(0.1));
assert!(matches!(x, AdValue::Reverse { .. }));

pub fn mode(&self) -> AdMode

Returns the AD mode.

Examples

use ad_tensors_rs::{AdMode, AdValue};

let x = AdValue::forward(1.0_f64, 1.0_f64);
assert_eq!(x.mode(), AdMode::Forward);

pub fn primal_ref(&self) -> &T

Returns a reference to the primal payload.

Examples

use ad_tensors_rs::AdValue;

let x = AdValue::forward(10_i32, 1_i32);
assert_eq!(x.primal_ref(), &10);

pub fn primal_mut(&mut self) -> &mut T

Returns a mutable reference to the primal payload.

Examples

use ad_tensors_rs::AdValue;

let mut x = AdValue::primal(1_i32);
*x.primal_mut() = 7;
assert_eq!(x.primal_ref(), &7);

pub fn tangent_ref(&self) -> Option<&T>

Returns a reference to tangent payload when available.

Examples

use ad_tensors_rs::AdValue;

let x = AdValue::forward(2.0_f64, 3.0_f64);
assert_eq!(x.tangent_ref(), Some(&3.0));

pub fn node_id(&self) -> Option<NodeId>

Returns reverse-mode node id when available.

Examples

use ad_tensors_rs::{AdValue, NodeId, TapeId};

let x = AdValue::reverse(1.0_f64, NodeId(4), TapeId(6), None);
assert_eq!(x.node_id(), Some(NodeId(4)));

pub fn tape_id(&self) -> Option<TapeId>

Returns reverse-mode tape id when available.

Examples

use ad_tensors_rs::{AdValue, NodeId, TapeId};

let x = AdValue::reverse(1.0_f64, NodeId(4), TapeId(6), None);
assert_eq!(x.tape_id(), Some(TapeId(6)));

pub fn map<U>(self, f: impl FnMut(T) -> U) -> AdValue<U>

Maps the payload type while preserving AD mode.

Examples

use ad_tensors_rs::AdValue;

let x = AdValue::forward(2_i32, 3_i32);
let y = x.map(|v| v as f64);
assert_eq!(y.primal_ref(), &2.0_f64);
assert_eq!(y.tangent_ref(), Some(&3.0_f64));

Trait Implementations

impl<T: Clone> Clone for AdValue<T>

fn clone(&self) -> AdValue<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AdValue<T>

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

Formats the value using the given formatter.

impl<T: Clone> Differentiable for AdValue<T>

type Primal = T

Underlying primal payload type.

fn ad_value(&self) -> &AdValue<T>

Borrow as an AdValue.

impl<T> From<AdScalar<T>> for AdValue<T>

fn from(value: AdScalar<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<AdTensor<T>> for AdValue<Tensor<T>>

fn from(value: AdTensor<T>) -> Self

Converts to this type from the input type.

impl From<AdValue<Complex<f32>>> for DynAdValue

fn from(value: AdValue<Complex32>) -> Self

Converts to this type from the input type.

impl From<AdValue<Complex<f64>>> for DynAdValue

fn from(value: AdValue<Complex64>) -> Self

Converts to this type from the input type.

impl<T> From<AdValue<T>> for AdScalar<T>

fn from(value: AdValue<T>) -> Self

Converts to this type from the input type.

impl<T: Scalar> From<AdValue<Tensor<T>>> for AdTensor<T>

fn from(value: AdValue<Tensor<T>>) -> Self

Converts to this type from the input type.

impl From<AdValue<f32>> for DynAdValue

fn from(value: AdValue<f32>) -> Self

Converts to this type from the input type.

impl From<AdValue<f64>> for DynAdValue

fn from(value: AdValue<f64>) -> Self

Converts to this type from the input type.

impl<T> From<T> for AdValue<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for AdValue<T>

fn eq(&self, other: &AdValue<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<T> StructuralPartialEq for AdValue<T>