Struct nalgebra::geometry::TransformBase
[−]
[src]
#[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>>,
[src]
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>>,
[src]
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>,
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>>,
[src]
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>,
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>>,
[src]
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>,
[src]
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>
[src]
impl<N: Clone + Scalar, D: Clone + DimNameAdd<U1>, S: Clone, C: Clone + TCategory> Clone for TransformBase<N, D, S, C>
[src]
fn clone(&self) -> TransformBase<N, D, S, C>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<N: Copy + Scalar, D: Copy + DimNameAdd<U1>, S: Copy, C: Copy + TCategory> Copy for TransformBase<N, D, S, C>
[src]
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>>,
[src]
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>>,
[src]
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 ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0
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>,
[src]
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>>,
[src]
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>>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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>,
[src]
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,
Self: ApproxEq,
Returns true
if associativity holds for the given arguments. Approximate equality is used for verifications. Read more
fn prop_is_associative(args: (Self, Self, Self)) -> bool where
Self: Eq,
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>,
[src]
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,
Self: ApproxEq,
Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications. Read more
fn prop_operating_identity_element_is_noop(a: Self) -> bool where
Self: Eq,
Self: Eq,
Checks whether operating with the identity element is a no-op for the given argument. Read more
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>,
[src]
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,
Self: ApproxEq,
Returns true
if latin squareness holds for the given arguments. Approximate equality is used for verifications. Read more
fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where
Self: Eq,
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>,
[src]
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>,
[src]
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>,
[src]
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. Read more
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>,
[src]
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>
&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>
&self,
v: &ColumnVector<N, D, SB>
) -> ColumnVector<N, D, SB>
Applies this group's inverse action on a vector from the euclidean space. Read more
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,
[src]
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. Read more
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,
[src]
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
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. Read more