Struct vecmat::transform::Affine

pub struct Affine<T, const N: usize> { /* fields omitted */ }

Affine transformation.

Implementations

impl<T, const N: usize> Affine<T, N>

pub fn new(linear: Linear<T, N>, shift: Shift<T, N>) -> Self

Construct affine transformation from linear one and shift.

pub fn split(self) -> (Linear<T, N>, Shift<T, N>)

Split into linear and shift components.

impl<T, const N: usize> Affine<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.

Trait Implementations

impl<T, const N: usize> AbsDiffEq<Affine<T, N>> for Affine<T, N> where
    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.

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

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: Clone, const N: usize> Clone for Affine<T, N>

fn clone(&self) -> Affine<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy, const N: usize> Copy for Affine<T, N>

impl<T: Debug, const N: usize> Debug for Affine<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Distribution<Affine<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.

pub 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.

impl<T, const N: usize> Distribution<Affine<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.

pub 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.

impl<T: PartialEq, const N: usize> PartialEq<Affine<T, N>> for Affine<T, N>

fn eq(&self, other: &Affine<T, N>) -> bool

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

fn ne(&self, other: &Affine<T, N>) -> bool

This method tests for !=.

impl<T, const N: usize> StructuralPartialEq for Affine<T, N>

impl<T, const N: usize> Transform<T, N> for Affine<T, N> where
    T: Neg<Output = T> + Num + Copy, 

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

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

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one.