Struct Transform3 

pub struct Transform3<S, U, V>(pub Matrix3<S>, _)
where
    S: Zero + One;

3D linear transformation between two coordinate systems tagged with units

Tuple Fields

0: Matrix3<S>

Trait Implementations

impl<S, U, V> Add for Transform3<S, U, V>

where S: Ring,

type Output = Transform3<S, U, V>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S, U, V> AddAssign for Transform3<S, U, V>

where S: Ring,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<S, U, V> Clone for Transform3<S, U, V>

where S: Clone + Zero + One,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, U: Debug, V: Debug> Debug for Transform3<S, U, V>

where S: Zero + One + Debug,

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

Formats the value using the given formatter.

impl<S, U: Default, V: Default> Default for Transform3<S, U, V>

where S: Zero + One + Default,

fn default() -> Transform3<S, U, V>

Returns the “default value” for a type.

impl<S, U, V> Display for Transform3<S, U, V>

where S: Zero + One, Matrix3<S>: Display,

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

Formats the value using the given formatter.

impl<S, U, V> FixedMatrix3<S> for Transform3<S, U, V>

where S: Fixed + Zero + One,

fn from_num<N: ToFixed>(num: Matrix3<N>) -> Self

fn wrapping_from_num<N: ToFixed>(num: Matrix3<N>) -> Self

impl<S, U, V> From<Mat3<S>> for Transform3<S, U, V>

where S: Zero + One,

fn from(matrix: Matrix3<S>) -> Self

Converts to this type from the input type.

impl<S, U, V> From<Transform2<S, U, V>> for Transform3<S, U, V>

where S: Field,

fn from(transform: Transform2<S, U, V>) -> Self

Converts to this type from the input type.

impl<S, U, V> From<Transform3<S, U, V>> for Transform4<S, U, V>

where S: Field,

fn from(transform: Transform3<S, U, V>) -> Self

Converts to this type from the input type.

impl<S, U, V> LinearMap<S, Displacement3<S, U>, Displacement3<S, V>> for Transform3<S, U, V>

where S: Ring,

fn determinant(self) -> S

fn transpose(self) -> Self

impl<S, U, V> Mul<Displacement3<S, U>> for Transform3<S, U, V>

where S: Ring,

type Output = Displacement3<S, V>

The resulting type after applying the * operator.

fn mul(self, rhs: Displacement3<S, U>) -> Displacement3<S, V>

Performs the * operation.

impl<S, U, V> Mul for Transform3<S, U, V>

where S: Ring,

type Output = Transform3<S, U, V>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S, U, V> MulAdd for Transform3<S, U, V>

where S: Ring,

type Output = Transform3<S, U, V>

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: Self, b: Self) -> Self

Performs the fused multiply-add operation (self * a) + b

impl<S, U, V> MulAddAssign for Transform3<S, U, V>

where S: Ring,

fn mul_add_assign(&mut self, a: Self, b: Self)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl<S, U, V> MulAssign for Transform3<S, U, V>

where S: Ring,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<S, U, V> Neg for Transform3<S, U, V>

where S: Ring,

type Output = Transform3<S, U, V>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<S, U, V> One for Transform3<S, U, V>

where S: Ring,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<S, U, V> PartialEq for Transform3<S, U, V>

where S: PartialEq + Zero + One,

fn eq(&self, other: &Self) -> 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<S, U, V> Sub for Transform3<S, U, V>

where S: Ring,

type Output = Transform3<S, U, V>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S, U, V> SubAssign for Transform3<S, U, V>

where S: Ring,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<S, U, V> Sum for Transform3<S, U, V>

where S: Ring,

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<S, U, V> Zero for Transform3<S, U, V>

where S: Ring,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<S, U, V> Copy for Transform3<S, U, V>

where S: Copy + Zero + One,

impl<S, U: Eq, V: Eq> Eq for Transform3<S, U, V>

where S: Zero + One + Eq,