Struct nalgebra::geometry::TransformBase

#[repr(C)]
pub struct TransformBase<N: Scalar, D: DimNameAdd<U1>, S, C: TCategory> { /* fields omitted */ }

A transformation matrix in homogeneous coordinates.

It is stored as a matrix with dimensions (D + 1, D + 1), e.g., it stores a 4x4 matrix for a 3D transformation.

Methods

impl<N, D, S, C: TCategory> TransformBase<N, D, S, C> where
    N: Scalar,
    D: DimNameAdd<U1>,
    S: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn from_matrix_unchecked(matrix: SquareMatrix<N, DimNameSum<D, U1>, S>) -> Self

Creates a new transformation from the given homogeneous matrix. The transformation category of Self is not checked to be verified by the given matrix.

fn into_owned(self) -> OwnedTransform<N, D, S::Alloc, C>

Moves this transform into one that owns its data.

fn clone_owned(&self) -> OwnedTransform<N, D, S::Alloc, C>

Clones this transform into one that owns its data.

fn unwrap(self) -> SquareMatrix<N, DimNameSum<D, U1>, S>

The underlying matrix.

fn matrix(&self) -> &SquareMatrix<N, DimNameSum<D, U1>, S>

A reference to the underlynig matrix.

fn matrix_mut_unchecked(&mut self) -> &mut SquareMatrix<N, DimNameSum<D, U1>, S>

A mutable reference to the underlying matrix.

It is _unchecked because direct modifications of this matrix may break invariants identified by this transformation category.

fn set_category<CNew: SuperTCategoryOf<C>>(self) -> TransformBase<N, D, S, CNew>

Sets the category of this transform.

This can be done only if the new category is more general than the current one, e.g., a transform with category TProjective cannot be converted to a transform with category TAffine because not all projective transformations are affine (the other way-round is valid though).

fn to_homogeneous(&self) -> OwnedSquareMatrix<N, DimNameSum<D, U1>, S::Alloc>

Converts this transform into its equivalent homogeneous transformation matrix.

impl<N, D, S, C> TransformBase<N, D, S, C> where
    N: Scalar + Field + ApproxEq,
    D: DimNameAdd<U1>,
    C: TCategory,
    S: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn try_inverse(self) -> Option<OwnedTransform<N, D, S::Alloc, C>>

Attempts to invert this transformation. You may use .inverse instead of this transformation has a subcategory of TProjective.

fn inverse(self) -> OwnedTransform<N, D, S::Alloc, C> where
    C: SubTCategoryOf<TProjective>, 

Inverts this transformation. Use .try_inverse if this transform has the TGeneral category (it may not be invertible).

impl<N, D, S, C> TransformBase<N, D, S, C> where
    N: Scalar + Field + ApproxEq,
    D: DimNameAdd<U1>,
    C: TCategory,
    S: StorageMut<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn try_inverse_mut(&mut self) -> bool

Attempts to invert this transformation in-place. You may use .inverse_mut instead of this transformation has a subcategory of TProjective.

fn inverse_mut(&mut self) where
    C: SubTCategoryOf<TProjective>, 

Inverts this transformation in-place. Use .try_inverse_mut if this transform has the TGeneral category (it may not be invertible).

impl<N, D, S> TransformBase<N, D, S, TGeneral> where
    N: Scalar,
    D: DimNameAdd<U1>,
    S: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn matrix_mut(&mut self) -> &mut SquareMatrix<N, DimNameSum<D, U1>, S>

A mutable reference to underlying matrix. Use .matrix_mut_unchecked instead if this transformation category is not TGeneral.

impl<N, D, S, C: TCategory> TransformBase<N, D, S, C> where
    N: Scalar + Zero + One,
    D: DimNameAdd<U1>,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn identity() -> Self

Creates a new identity transform.

Trait Implementations

impl<N: Debug + Scalar, D: Debug + DimNameAdd<U1>, S: Debug, C: Debug + TCategory> Debug for TransformBase<N, D, S, C>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<N: Clone + Scalar, D: Clone + DimNameAdd<U1>, S: Clone, C: Clone + TCategory> Clone for TransformBase<N, D, S, C>

fn clone(&self) -> TransformBase<N, D, S, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy + Scalar, D: Copy + DimNameAdd<U1>, S: Copy, C: Copy + TCategory> Copy for TransformBase<N, D, S, C>

impl<N, D, S, C: TCategory> Eq for TransformBase<N, D, S, C> where
    N: Scalar + Eq,
    D: DimNameAdd<U1>,
    S: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

impl<N, D, S, C: TCategory> PartialEq for TransformBase<N, D, S, C> where
    N: Scalar,
    D: DimNameAdd<U1>,
    S: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn eq(&self, right: &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 !=.

impl<N, D, S, C: TCategory> One for TransformBase<N, D, S, C> where
    N: Scalar + Field,
    D: DimNameAdd<U1>,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn one() -> Self

Creates a new identity transform.

impl<N, D, S, C: TCategory> Index<(usize, usize)> for TransformBase<N, D, S, C> where
    N: Scalar,
    D: DimName + DimNameAdd<U1>,
    S: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = N

The returned type after indexing

fn index(&self, ij: (usize, usize)) -> &N

The method for the indexing (container[index]) operation

impl<N, D, S> IndexMut<(usize, usize)> for TransformBase<N, D, S, TGeneral> where
    N: Scalar,
    D: DimName + DimNameAdd<U1>,
    S: StorageMut<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn index_mut(&mut self, ij: (usize, usize)) -> &mut N

The method for the mutable indexing (container[index]) operation

impl<N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<ColumnVector<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedColumnVector<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: ColumnVector<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<ColumnVector<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedColumnVector<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: ColumnVector<N, D, SB>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<&'b ColumnVector<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedColumnVector<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: &'b ColumnVector<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<&'b ColumnVector<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedColumnVector<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: &'b ColumnVector<N, D, SB>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<PointBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedPoint<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: PointBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<PointBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedPoint<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: PointBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<&'b PointBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedPoint<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: &'b PointBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> Mul<&'b PointBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: Allocator<N, D, D>,
    SA::Alloc: Allocator<N, D, U1>,
    SA::Alloc: Allocator<N, U1, D>, 

type Output = OwnedPoint<N, D, SA::Alloc>

The resulting type after applying the * operator

fn mul(self, rhs: &'b PointBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory, SA, SB> Mul<TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: TransformBase<N, D, SB, CB>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory, SA, SB> Mul<TransformBase<N, D, SB, CB>> for &'a TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: TransformBase<N, D, SB, CB>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory, SA, SB> Mul<&'b TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b TransformBase<N, D, SB, CB>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory, SA, SB> Mul<&'b TransformBase<N, D, SB, CB>> for &'a TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b TransformBase<N, D, SB, CB>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: RotationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<RotationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: RotationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b RotationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b RotationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b RotationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<N, C: TCategoryMul<TAffine>, SA, SB> Mul<UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output

The method for the * operator

impl<'a, N, C: TCategoryMul<TAffine>, SA, SB> Mul<UnitQuaternionBase<N, SB>> for &'a TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output

The method for the * operator

impl<'b, N, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b UnitQuaternionBase<N, SB>> for &'a TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<IsometryBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: IsometryBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<IsometryBase<N, D, SB, R>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: IsometryBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<&'b IsometryBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b IsometryBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<&'b IsometryBase<N, D, SB, R>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b IsometryBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<SimilarityBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: SimilarityBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<SimilarityBase<N, D, SB, R>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: SimilarityBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<&'b SimilarityBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b SimilarityBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> Mul<&'b SimilarityBase<N, D, SB, R>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b SimilarityBase<N, D, SB, R>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: TranslationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<TranslationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: TranslationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b TranslationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b TranslationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the * operator

fn mul(self, rhs: &'b TranslationBase<N, D, SB>) -> Self::Output

The method for the * operator

impl<N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>, SA, SB> Div<TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + ApproxEq + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the / operator

fn div(self, rhs: TransformBase<N, D, SB, CB>) -> Self::Output

The method for the / operator

impl<'a, N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>, SA, SB> Div<TransformBase<N, D, SB, CB>> for &'a TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + ApproxEq + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the / operator

fn div(self, rhs: TransformBase<N, D, SB, CB>) -> Self::Output

The method for the / operator

impl<'b, N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>, SA, SB> Div<&'b TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + ApproxEq + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b TransformBase<N, D, SB, CB>) -> Self::Output

The method for the / operator

impl<'a, 'b, N, D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>, SA, SB> Div<&'b TransformBase<N, D, SB, CB>> for &'a TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + ApproxEq + Field,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, CA::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b TransformBase<N, D, SB, CB>) -> Self::Output

The method for the / operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: RotationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<RotationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: RotationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<&'b RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b RotationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<&'b RotationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b RotationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<N, C: TCategoryMul<TAffine>, SA, SB> Div<UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output

The method for the / operator

impl<'a, N, C: TCategoryMul<TAffine>, SA, SB> Div<UnitQuaternionBase<N, SB>> for &'a TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output

The method for the / operator

impl<'b, N, C: TCategoryMul<TAffine>, SA, SB> Div<&'b UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output

The method for the / operator

impl<'a, 'b, N, C: TCategoryMul<TAffine>, SA, SB> Div<&'b UnitQuaternionBase<N, SB>> for &'a TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

type Output = OwnedTransform<N, U3, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output

The method for the / operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: TranslationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<TranslationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: TranslationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<&'b TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b TranslationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<&'b TranslationBase<N, D, SB>> for &'a TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>

The resulting type after applying the / operator

fn div(self, rhs: &'b TranslationBase<N, D, SB>) -> Self::Output

The method for the / operator

impl<N, D: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>, SA, SB> MulAssign<TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>, 

fn mul_assign(&mut self, rhs: TransformBase<N, D, SB, CB>)

The method for the *= operator

impl<'b, N, D: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>, SA, SB> MulAssign<&'b TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>, 

fn mul_assign(&mut self, rhs: &'b TransformBase<N, D, SB, CB>)

The method for the *= operator

impl<N, D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> MulAssign<SimilarityBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB::Alloc: Allocator<N, D, D>, 

fn mul_assign(&mut self, rhs: SimilarityBase<N, D, SB, R>)

The method for the *= operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> MulAssign<&'b SimilarityBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB::Alloc: Allocator<N, D, D>, 

fn mul_assign(&mut self, rhs: &'b SimilarityBase<N, D, SB, R>)

The method for the *= operator

impl<N, D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> MulAssign<IsometryBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn mul_assign(&mut self, rhs: IsometryBase<N, D, SB, R>)

The method for the *= operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SB::Alloc>>, SA, SB> MulAssign<&'b IsometryBase<N, D, SB, R>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn mul_assign(&mut self, rhs: &'b IsometryBase<N, D, SB, R>)

The method for the *= operator

impl<N, D: DimNameAdd<U1>, C: TCategory, SA, SB> MulAssign<TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn mul_assign(&mut self, rhs: TranslationBase<N, D, SB>)

The method for the *= operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> MulAssign<&'b TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn mul_assign(&mut self, rhs: &'b TranslationBase<N, D, SB>)

The method for the *= operator

impl<N, D: DimNameAdd<U1>, C: TCategory, SA, SB> MulAssign<RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn mul_assign(&mut self, rhs: RotationBase<N, D, SB>)

The method for the *= operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> MulAssign<&'b RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn mul_assign(&mut self, rhs: &'b RotationBase<N, D, SB>)

The method for the *= operator

impl<N, C: TCategory, SA, SB> MulAssign<UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: OwnedStorage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SA::Alloc: OwnedAllocator<N, U4, U4, SA>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

fn mul_assign(&mut self, rhs: UnitQuaternionBase<N, SB>)

The method for the *= operator

impl<'b, N, C: TCategory, SA, SB> MulAssign<&'b UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: OwnedStorage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SA::Alloc: OwnedAllocator<N, U4, U4, SA>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

fn mul_assign(&mut self, rhs: &'b UnitQuaternionBase<N, SB>)

The method for the *= operator

impl<N, D: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>, SA, SB> DivAssign<TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field + ApproxEq,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>, 

fn div_assign(&mut self, rhs: TransformBase<N, D, SB, CB>)

The method for the /= operator

impl<'b, N, D: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>, SA, SB> DivAssign<&'b TransformBase<N, D, SB, CB>> for TransformBase<N, D, SA, CA> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Field + ApproxEq,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>, 

fn div_assign(&mut self, rhs: &'b TransformBase<N, D, SB, CB>)

The method for the /= operator

impl<N, D: DimNameAdd<U1>, C: TCategory, SA, SB> DivAssign<TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One + ClosedNeg,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn div_assign(&mut self, rhs: TranslationBase<N, D, SB>)

The method for the /= operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> DivAssign<&'b TranslationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One + ClosedNeg,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, U1>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn div_assign(&mut self, rhs: &'b TranslationBase<N, D, SB>)

The method for the /= operator

impl<N, D: DimNameAdd<U1>, C: TCategory, SA, SB> DivAssign<RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn div_assign(&mut self, rhs: RotationBase<N, D, SB>)

The method for the /= operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategory, SA, SB> DivAssign<&'b RotationBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + One,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: Storage<N, D, D>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

fn div_assign(&mut self, rhs: &'b RotationBase<N, D, SB>)

The method for the /= operator

impl<N, C: TCategory, SA, SB> DivAssign<UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: OwnedStorage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SA::Alloc: OwnedAllocator<N, U4, U4, SA>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

fn div_assign(&mut self, rhs: UnitQuaternionBase<N, SB>)

The method for the /= operator

impl<'b, N, C: TCategory, SA, SB> DivAssign<&'b UnitQuaternionBase<N, SB>> for TransformBase<N, U3, SA, C> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: OwnedStorage<N, U4, U4>,
    SB: Storage<N, U4, U1>,
    SA::Alloc: OwnedAllocator<N, U4, U4, SA>,
    SB::Alloc: Allocator<N, U3, U3>,
    SB::Alloc: Allocator<N, U4, U4>, 

fn div_assign(&mut self, rhs: &'b UnitQuaternionBase<N, SB>)

The method for the /= operator

impl<N, D: DimNameAdd<U1>, S, C> Identity<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: TCategory,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn identity() -> Self

The identity element.

impl<N, D: DimNameAdd<U1>, S, C> Inverse<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field + ApproxEq,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: SubTCategoryOf<TProjective>,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn inverse(&self) -> Self

Returns the inverse of self, relative to the operator O.

fn inverse_mut(&mut self)

In-place inversin of self.

impl<N, D: DimNameAdd<U1>, S, C> AbstractMagma<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: TCategory,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn operate(&self, rhs: &Self) -> Self

Performs an operation.

fn op(&self, O, lhs: &Self) -> Self

Performs specific operation.

impl<N, D: DimNameAdd<U1>, S, C> AbstractSemigroup<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: TCategory,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
    Self: ApproxEq, 

Returns true if associativity holds for the given arguments. Approximate equality is used for verifications.

fn prop_is_associative(args: (Self, Self, Self)) -> bool where
    Self: Eq, 

Returns true if associativity holds for the given arguments.

impl<N, D: DimNameAdd<U1>, S, C> AbstractMonoid<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: TCategory,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn prop_operating_identity_element_is_noop_approx(a: Self) -> bool where
    Self: ApproxEq, 

Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications.

fn prop_operating_identity_element_is_noop(a: Self) -> bool where
    Self: Eq, 

Checks whether operating with the identity element is a no-op for the given argument.

impl<N, D: DimNameAdd<U1>, S, C> AbstractQuasigroup<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field + ApproxEq,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: SubTCategoryOf<TProjective>,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where
    Self: ApproxEq, 

Returns true if latin squareness holds for the given arguments. Approximate equality is used for verifications.

fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where
    Self: Eq, 

Returns true if latin squareness holds for the given arguments.

impl<N, D: DimNameAdd<U1>, S, C> AbstractLoop<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field + ApproxEq,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: SubTCategoryOf<TProjective>,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

impl<N, D: DimNameAdd<U1>, S, C> AbstractGroup<Multiplicative> for TransformBase<N, D, S, C> where
    N: Scalar + Field + ApproxEq,
    S: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: SubTCategoryOf<TProjective>,
    S::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, S>, 

impl<N, D: DimNameAdd<U1>, SA, SB, C> Transformation<PointBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Real,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
    C: TCategory,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA> + Allocator<N, D, D> + Allocator<N, D, U1> + Allocator<N, U1, D>,
    SB::Alloc: OwnedAllocator<N, D, U1, SB>, 

fn transform_point(&self, pt: &PointBase<N, D, SB>) -> PointBase<N, D, SB>

Applies this group's action on a point from the euclidean space.

fn transform_vector(&self, v: &ColumnVector<N, D, SB>) -> ColumnVector<N, D, SB>

Applies this group's action on a vector from the euclidean space.

impl<N, D: DimNameAdd<U1>, SA, SB, C> ProjectiveTransformation<PointBase<N, D, SB>> for TransformBase<N, D, SA, C> where
    N: Real,
    SA: OwnedStorage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
    C: SubTCategoryOf<TProjective>,
    SA::Alloc: OwnedAllocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>, SA> + Allocator<N, D, D> + Allocator<N, D, U1> + Allocator<N, U1, D>,
    SB::Alloc: OwnedAllocator<N, D, U1, SB>, 

fn inverse_transform_point(
    &self,
    pt: &PointBase<N, D, SB>
) -> PointBase<N, D, SB>

Applies this group's inverse action on a point from the euclidean space.

fn inverse_transform_vector(
    &self,
    v: &ColumnVector<N, D, SB>
) -> ColumnVector<N, D, SB>

Applies this group's inverse action on a vector from the euclidean space.

impl<N1, N2, D: DimName, SA, SB, C1, C2> SubsetOf<TransformBase<N2, D, SB, C2>> for TransformBase<N1, D, SA, C1> where
    N1: Scalar + Field + ApproxEq + SubsetOf<N2>,
    N2: Scalar + Field + ApproxEq,
    C1: TCategory,
    C2: SuperTCategoryOf<C1>,
    D: DimNameAdd<U1>,
    SA: OwnedStorage<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::Alloc: OwnedAllocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB>,
    N1::Epsilon: Copy,
    N2::Epsilon: Copy, 

fn to_superset(&self) -> TransformBase<N2, D, SB, C2>

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(t: &TransformBase<N2, D, SB, C2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(t: &TransformBase<N2, D, SB, C2>) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2, D: DimName, SA, SB, C> SubsetOf<SquareMatrix<N2, DimNameSum<D, U1>, SB>> for TransformBase<N1, D, SA, C> where
    N1: Scalar + Field + ApproxEq + SubsetOf<N2>,
    N2: Scalar + Field + ApproxEq,
    C: TCategory,
    D: DimNameAdd<U1>,
    SA: OwnedStorage<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::Alloc: OwnedAllocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>, SA>,
    SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB>,
    N1::Epsilon: Copy,
    N2::Epsilon: Copy, 

fn to_superset(&self) -> SquareMatrix<N2, DimNameSum<D, U1>, SB>

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(m: &SquareMatrix<N2, DimNameSum<D, U1>, SB>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(
    m: &SquareMatrix<N2, DimNameSum<D, U1>, SB>
) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.