Struct vecmat::transform::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<Chain<A, B, T>> for Chain<A, B, T> where
    A: AbsDiffEq<Epsilon = T>,
    B: AbsDiffEq<Epsilon = T>,
    T: AbsDiffEq<Epsilon = T> + Copy, 

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) -> Chain<A, B, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

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>>, 

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, 

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, 

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>>, 

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, 

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, 

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<Chain<A, B, T>> for Chain<A, B, T>

fn eq(&self, other: &Chain<A, B, T>) -> bool

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

fn ne(&self, other: &Chain<A, B, T>) -> bool

This method tests for !=.

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.

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

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