Struct easy_ml::differentiation::Record

pub struct Record<'a, T: Primitive> {
    pub number: T,
    pub index: Index,
    /* private fields */
}

A wrapper around a real number which records it going through the computational graph. This is used to perform Reverse Mode Automatic Differentiation.

Panics

Every operation and nearly every method a Record has involves manipulating the record’s history on its referenced WengertList. This WengertList itself maintains a RefCell which tracks borrows at runtime rather than compile time. This is neccessary to maintain the illusion that Records are just ordinary numbers, and the side effects of doing arithmetic with Records are limited to their referenced WengertList. Hence, the Rust compiler infers that it is not safe to share references to WengertLists between threads, nor transfer Records across threads. If you called a method on two Records that both mutably borrowed from the same WengertList at once, which could be trivially done with multiple threads, then the code would panic. Easy ML shouldn’t allow you to do this in safe Rust because each mutable borrow of the WengertList is dropped at the end of each Record method call, and you can’t call two methods simulatenously without threading.

Acknowledgments

A tutorial by Rufflewind and the associated MIT licensed soure code were invaluable in providing understanding on how to implement Reverse Mode Automatic Differentiation.

Fields

number: T

The real number

index: Index

The index of this number in its WengertList. The first entry will be 0, the next 1 and so on.

In normal use cases you should not need to read this field, you can index Derivatives directly with Records.

Implementations

impl<'a, T: Numeric + Primitive> Record<'a, T>

The main set of methods for using Record types for Reverse Differentiation.

The general steps are

1. create a WengertList
2. create variables from this list
3. do operations on the variables
4. from the output you want to compute derivatives for call .derivatives()
5. index the Derivatives object with the index variables to get the derivatives with respect to each input
6. if you want to make another pass call clear() on the WengertList and then call reset() on all of the variables to forget the gradients already computed (the order of clear then reset is very important!).

Constants can be used to save memory if you have numbers that you do not need to compute the gradients with respect to.

pub fn constant(c: T) -> Record<'a, T>

Creates an untracked Record which has no backing WengertList.

This is provided for using constants along with Records in operations.

For example with y = x + 4 the computation graph could be conceived as a y node with parent nodes of x and 4 combined with the operation +. However there is no need to record the derivatives of a constant, so instead the computation graph can be conceived as a y node with a single parent node of x and the unary operation of +4.

This is also used for the type level constructors required by Numeric which are also considered constants.

pub fn variable(x: T, history: &'a WengertList<T>) -> Record<'a, T>

Creates a record backed by the provided WengertList.

The record cannot live longer than the WengertList, hence the following example does not compile

use easy_ml::differentiation::Record;
use easy_ml::differentiation::WengertList;
let record = {
    let list = WengertList::new();
    Record::variable(1.0, &list)
}; // list no longer in scope

You can alternatively use the record constructor on the WengertList type.

pub fn from_existing( number: (T, Index), history: Option<&'a WengertList<T>> ) -> Record<'a, T>

Creates a record from a constant/variable directly, most likely obtained by getting a tensor view of an existing container. The inputs are not checked for validity. It is possible to pass in the wrong Wengert list here or even numbers with indexes that aren’t tracked on the WengertList.

It is recommended to use this constructor only in conjunction with manipulating an existing container and not for creating new variables. Any variables created outside of Record::variable / RecordContainer::variables would have to be manually added to the correct Wengert list, and any arithmetic operations would also need tracking correctly.

pub fn reset(&mut self)

Resets this Record to place it back on its WengertList, for use in performing another derivation after clearing the WengertList.

pub fn do_reset(x: Record<'_, T>) -> Record<'_, T>

A convenience helper function which takes a Record by value and calls reset on it.

pub fn history(&self) -> Option<&'a WengertList<T>>

Gets the WengertList this Record is backed by if a variable, and None if a constant.

impl<'a, T: Numeric + Primitive> Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

pub fn derivatives(&self) -> Derivatives<T>

Performs a backward pass up this record’s WengertList from this record as the output, computing all the derivatives for the inputs involving this output.

If you have N inputs x₁ to x_N, and this output is y, then this computes all the derivatives δy/δx_i for i = 1 to N.

Panics

Panics if the Record has no backing WengertList, ie it was created as a constant.

pub fn try_derivatives(&self) -> Option<Derivatives<T>>

Performs a backward pass up this record’s WengertList from this record as the output, computing all the derivatives for the inputs involving this output.

If this record has no WengertList, ie it’s a constant, None is returned instead.

If you have N inputs x₁ to x_N, and this output is y, then this computes all the derivatives δy/δx_i for i = 1 to N.

impl<'a, T: Numeric + Primitive> Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

pub fn unary( &self, fx: impl Fn(T) -> T, dfx_dx: impl Fn(T) -> T ) -> Record<'_, T>

Creates a new Record from a reference to an existing Record by applying some unary function to it which operates on the type the Record wraps.

To compute the new record, the unary function of some input x to some output y is needed along with its derivative with respect to its input x.

For example, tanh is a commonly used activation function, but the Real trait does not include this operation and Record has no operations for it specifically. However, you can use this function to compute the tanh of a Record like so:

use easy_ml::differentiation::{Record, WengertList};
let list = WengertList::new();
let x = Record::variable(0.7f32, &list);
// the derivative of tanh(x) is sech(x) * sech(x) which is equivalent to
// 1 / (cosh(x) * cosh(x))
let y = x.unary(|x| x.tanh(), |x| 1.0 / (x.cosh() * x.cosh()));
assert_eq!(y.derivatives()[&x], 1.0f32 / (0.7f32.cosh() * 0.7f32.cosh()));

pub fn binary( &self, rhs: &Record<'a, T>, fxy: impl Fn(T, T) -> T, dfxy_dx: impl Fn(T, T) -> T, dfxy_dy: impl Fn(T, T) -> T ) -> Record<'_, T>

Creates a new Record from a reference to two existing Records by applying some binary function to them which operates on two arguments of the type the Records wrap.

To compute the new record, the binary function of some inputs x and y to some output z is needed along with its derivative with respect to its first input x and its derivative with respect to its second input y.

For example, atan2 takes two arguments, but the Real trait does not include this operation and Record has no operations for it specifically. However, you can use this function to compute the atan2 of two Records like so:

use easy_ml::differentiation::{Record, WengertList};
let list = WengertList::new();
let x = Record::variable(3.0f32, &list);
let y = Record::variable(3.0f32, &list);
// the derivative of atan2 with respect to x is y/(x*x + y*y)
// https://www.wolframalpha.com/input/?i=d%28atan2%28x%2Cy%29%29%2Fdx
// the derivative of atan2 with respect to y is -x/(x*x + y*y)
// https://www.wolframalpha.com/input/?i=d%28atan2%28x%2Cy%29%29%2Fdy
let z = x.binary(&y,
    |x, y| x.atan2(y),
    |x, y| y/((x*x) + (y*y)),
    |x, y| -x/((x*x) + (y*y))
);
let derivatives = z.derivatives();
let dx = derivatives[&x];
let dy = derivatives[&y];

Trait Implementations

impl<'a, 'l, 'r, T: Numeric + Primitive> Add<&'r Record<'a, T>> for &'l Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Addition for two records of the same type with both referenced and both using the same WengertList.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: &Record<'a, T>) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add<&Record<'a, T>> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: &Record<'a, T>) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add<&T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Addition for a record and a constant of the same type with both referenced.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add<&T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add<Record<'a, T>> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: Record<'a, T>) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add<T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add<T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'a, T: Numeric + Primitive> Add for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type.

type Output = Record<'a, T>

The resulting type after applying the + operator.

fn add(self, rhs: Record<'a, T>) -> Self::Output

Performs the + operation.

impl<'a, T: Clone + Primitive> Clone for Record<'a, T>

Any record of a Cloneable type implements clone

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Numeric + Real + Primitive> Cos for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Cosine of a Record by reference.

type Output = Record<'a, T>

fn cos(self) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Cos for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record by value.

type Output = Record<'a, T>

fn cos(self) -> Self::Output

impl<'a, T: Debug + Primitive> Debug for Record<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Display + Primitive> Display for Record<'a, T>

A record is displayed by showing its number component.

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

Formats the value using the given formatter.

impl<'a, 'l, 'r, T: Numeric + Primitive> Div<&'r Record<'a, T>> for &'l Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Dvision for two records of the same type with both referenced and both using the same WengertList.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: &Record<'a, T>) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div<&Record<'a, T>> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: &Record<'a, T>) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div<&T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Division for a record and a constant of the same type with both referenced.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: &T) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div<&T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: &T) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div<Record<'a, T>> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: Record<'a, T>) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div<T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div<T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Primitive> Div for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type.

type Output = Record<'a, T>

The resulting type after applying the / operator.

fn div(self, rhs: Record<'a, T>) -> Self::Output

Performs the / operation.

impl<'a, T: Numeric + Real + Primitive> Exp for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Exponential, ie e^x of a Record by reference.

type Output = Record<'a, T>

fn exp(self) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Exp for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record by value.

type Output = Record<'a, T>

fn exp(self) -> Self::Output

impl<'a, T> From<&Record<'a, T>> for RecordTensor<'a, T, Tensor<(T, Index), 0>, 0>

where T: Numeric + Primitive,

A record can be converted losslessly into a zero dimensional record tensor.

fn from(record: &Record<'a, T>) -> RecordTensor<'a, T, Tensor<(T, Index), 0>, 0>

Converts a record into a zero dimensional record tensor with the single element.

impl<'a, T, S> From<&RecordContainer<'a, T, TensorView<(T, usize), S, 0>, 0>> for Record<'a, T>

where T: Numeric + Primitive, S: TensorRef<(T, Index), 0>,

A zero dimensional record tensor can be converted losslessly into a record.

fn from(scalar: &RecordTensor<'a, T, S, 0>) -> Record<'a, T>

Converts the sole element in the zero dimensional record tensor into a record.

impl<'a, T> From<Record<'a, T>> for RecordTensor<'a, T, Tensor<(T, Index), 0>, 0>

where T: Numeric + Primitive,

A record can be converted losslessly into a zero dimensional record tensor.

fn from(record: Record<'a, T>) -> RecordTensor<'a, T, Tensor<(T, Index), 0>, 0>

Converts a record into a zero dimensional record tensor with the single element.

impl<'a, T, S> From<RecordContainer<'a, T, TensorView<(T, usize), S, 0>, 0>> for Record<'a, T>

where T: Numeric + Primitive, S: TensorRef<(T, Index), 0>,

A zero dimensional record tensor can be converted losslessly into a record.

fn from(scalar: RecordTensor<'a, T, S, 0>) -> Record<'a, T>

Converts the sole element in the zero dimensional record tensor into a record.

impl<'a, T: Numeric + Primitive> FromUsize for Record<'a, T>

fn from_usize(n: usize) -> Option<Record<'a, T>>

impl<'a, T: Primitive> Index<&Record<'a, T>> for Derivatives<T>

fn index(&self, input: &Record<'a, T>) -> &Self::Output

Quries the derivative at the provided record as input.

If you construct a Derivatives object for some output y, and call .at(&x) on it for some input x, this returns dy/dx.

type Output = T

The returned type after indexing.

impl<'a, T: Numeric + Real + Primitive> Ln for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Natural logarithm, ie ln(x) of a Record by reference.

type Output = Record<'a, T>

fn ln(self) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Ln for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record by value.

type Output = Record<'a, T>

fn ln(self) -> Self::Output

impl<'a, 'l, 'r, T: Numeric + Primitive> Mul<&'r Record<'a, T>> for &'l Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Multiplication for two records of the same type with both referenced and both using the same WengertList.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Record<'a, T>) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul<&Record<'a, T>> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Record<'a, T>) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul<&T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Multiplication for a record and a constant of the same type with both referenced.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul<&T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul<Record<'a, T>> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: Record<'a, T>) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul<T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul<T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Mul for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type.

type Output = Record<'a, T>

The resulting type after applying the * operator.

fn mul(self, rhs: Record<'a, T>) -> Self::Output

Performs the * operation.

impl<'a, T: Numeric + Primitive> Neg for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Negation of a record by reference.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T: Numeric + Primitive> Neg for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Negation of a record by value.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T: PartialEq + Primitive> PartialEq for Record<'a, T>

Any record of a PartialEq type implements PartialEq

Note that as a Record is intended to be substitutable with its type T only the number parts of the record are compared.

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T: PartialOrd + Primitive> PartialOrd for Record<'a, T>

Any record of a PartialOrd type implements PartialOrd

Note that as a Record is intended to be substitutable with its type T only the number parts of the record are compared.

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T: Numeric + Real + Primitive> Pi for Record<'a, T>

fn pi() -> Record<'a, T>

impl<'a, 'l, 'r, T: Numeric + Real + Primitive> Pow<&'r Record<'a, T>> for &'l Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Power of one Record to another, ie self^rhs for two records of the same type with both referenced and both using the same WengertList.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&Record<'a, T>> for &T

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Power of a constant to a Record of the same type with both referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&Record<'a, T>> for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for two records of the same type with the right referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&Record<'a, T>> for T

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a constant and a record of the same type with the right referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Power of one Record to a constant of the same type with both referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &T) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record and a constant of the same type with the right referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &T) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for two records of the same type with the left referenced.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for &T

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a constant and a record of the same type with the left referenced.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for T

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a constant and a record of the same type.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record and a constant of the same type with the left referenced.

type Output = Record<'a, T>

fn pow(self, rhs: T) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record and a constant of the same type.

type Output = Record<'a, T>

fn pow(self, rhs: T) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for two records of the same type.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Sin for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Sine of a Record by reference.

type Output = Record<'a, T>

fn sin(self) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Sin for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record by value.

type Output = Record<'a, T>

fn sin(self) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Sqrt for &Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Square root of a Record by reference.

type Output = Record<'a, T>

fn sqrt(self) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Sqrt for Record<'a, T>

where for<'t> &'t T: NumericRef<T> + RealRef<T>,

Operation for a record by value.

type Output = Record<'a, T>

fn sqrt(self) -> Self::Output

impl<'a, 'l, 'r, T: Numeric + Primitive> Sub<&'r Record<'a, T>> for &'l Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Subtraction for two records of the same type with both referenced and both using the same WengertList.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Record<'a, T>) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub<&Record<'a, T>> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Record<'a, T>) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub<&T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Subtraction for a record and a constant of the same type with both referenced.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub<&T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the right referenced.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub<Record<'a, T>> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: Record<'a, T>) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub<T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type with the left referenced.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub<T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for a record and a constant of the same type.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sub for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

Operation for two records of the same type.

type Output = Record<'a, T>

The resulting type after applying the - operator.

fn sub(self, rhs: Record<'a, T>) -> Self::Output

Performs the - operation.

impl<'a, T: Numeric + Primitive> Sum for Record<'a, T>

Any record of a Numeric type implements Sum, which is the same as adding a bunch of Record types together.

fn sum<I>(iter: I) -> Record<'a, T>

where I: Iterator<Item = Record<'a, T>>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: Numeric + Primitive> SwappedOperations<&T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

fn sub_swapped(self, lhs: &T) -> Self::Output

Subtraction for a record and a constant, where the constant is the left hand side, ie C - record.

fn div_swapped(self, lhs: &T) -> Self::Output

Division for a record and a constant, where the constant is the left hand side, ie C / record.

type Output = Record<'a, T>

impl<'a, T: Numeric + Primitive> SwappedOperations<&T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

fn sub_swapped(self, lhs: &T) -> Self::Output

Subtraction for a record and a constant, where the constant is the left hand side, ie C - record.

fn div_swapped(self, lhs: &T) -> Self::Output

Division for a record and a constant, where the constant is the left hand side, ie C / record.

type Output = Record<'a, T>

impl<'a, T: Numeric + Primitive> SwappedOperations<T> for &Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

fn sub_swapped(self, lhs: T) -> Self::Output

Subtraction for a record and a constant, where the constant is the left hand side, ie C - record.

fn div_swapped(self, lhs: T) -> Self::Output

Division for a record and a constant, where the constant is the left hand side, ie C / record.

type Output = Record<'a, T>

impl<'a, T: Numeric + Primitive> SwappedOperations<T> for Record<'a, T>

where for<'t> &'t T: NumericRef<T>,

fn sub_swapped(self, lhs: T) -> Self::Output

Subtraction for a record and a constant, where the constant is the left hand side, ie C - record.

fn div_swapped(self, lhs: T) -> Self::Output

Division for a record and a constant, where the constant is the left hand side, ie C / record.

type Output = Record<'a, T>

impl<'a, T: Numeric + Primitive> ZeroOne for Record<'a, T>

Record implements ZeroOne by returning constants.

fn zero() -> Record<'a, T>

fn one() -> Record<'a, T>

impl<'a, T: Copy + Primitive> Copy for Record<'a, T>

Any record of a Copy type implements Copy