Struct Chain 

pub struct Chain<A, B, T> { /* private fields */ }

Transformation obtained by combining two other ones.

Transformations are applied in the following order: A(B(x)).

Implementations

impl<T, const N: usize> Chain<Shift<T, N>, Linear<T, N>, Vector<T, N>>

where T: Copy,

pub fn linear(&self) -> Linear<T, N>

Linear component of the transformation.

pub fn shift(&self) -> Shift<T, N>

Shift component of the transformation.

impl<A, B, T> Chain<A, B, T>

pub fn new(outer: A, inner: B) -> Self

Construct chained transformation from outer and inner ones.

pub fn split(self) -> (A, B)

Split into two components components.

pub fn outer(&self) -> &A

Get outer transformation reference.

pub fn outer_mut(&mut self) -> &mut A

Get outer transformation mutable reference.

pub fn inner(&self) -> &B

Get inner transformation reference.

pub fn inner_mut(&mut self) -> &mut B

Get inner transformation mutable reference.

Trait Implementations

impl<A, B, T> AbsDiffEq for Chain<A, B, T>

where A: AbsDiffEq<Epsilon = T>, B: AbsDiffEq<Epsilon = T>, T: AbsDiffEq<Epsilon = T> + Copy,

Available on crate feature approx only.

type Epsilon = T

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<A: Clone, B: Clone, T: Clone> Clone for Chain<A, B, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Copy, B: Copy, T: Copy> Copy for Chain<A, B, T>

impl<A: Debug, B: Debug, T: Debug> Debug for Chain<A, B, T>

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

Formats the value using the given formatter.

impl<A, B, T> Directional<T> for Chain<A, B, T>

where A: Directional<T>, B: Directional<T>, Self: Transform<T>, T: Normalize + Copy,

fn apply_dir(&self, pos: T, dir: T) -> T

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, pos: T, normal: T) -> T

Returns the result of the normal transformation at the specified position.

impl<T, const N: usize> Distribution<Chain<Shift<T, N>, Linear<T, N>, Vector<T, N>>> for Normal

where Normal: Distribution<Linear<T, N>> + Distribution<Shift<T, N>>,

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Affine<T, N>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<T, const N: usize> Distribution<Chain<Shift<T, N>, Linear<T, N>, Vector<T, N>>> for Invertible

where Invertible: Distribution<Linear<T, N>>, Normal: Distribution<Shift<T, N>>,

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Affine<T, N>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<A, B, T> From<(A, B)> for Chain<A, B, T>

fn from((a, b): (A, B)) -> Self

Converts to this type from the input type.

impl<A, B, T> From<Chain<A, B, T>> for (A, B)

fn from(c: Chain<A, B, T>) -> Self

Converts to this type from the input type.

impl<A: PartialEq, B: PartialEq, T: PartialEq> PartialEq for Chain<A, B, T>

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

Equality operator ==.

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

Inequality operator !=.

impl<A: PartialEq, B: PartialEq, T: PartialEq> StructuralPartialEq for Chain<A, B, T>

impl<A, B, T> Transform<T> for Chain<A, B, T>

where A: Transform<T> + Reorder<B, T>, B: Transform<T> + Reorder<A, T>, T: Copy,

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: T) -> T

Perform the transformation itself.

fn deriv(&self, pos: T, dir: T) -> T

Find transformation directional derivative at specified point.

fn chain(self, other: Self) -> Self

Chain two transformations into a new one.