Struct nalgebra::geometry::IsometryBase

#[repr(C)]
pub struct IsometryBase<N: Scalar, D: DimName, S, R> {
    pub rotation: R,
    pub translation: TranslationBase<N, D, S>,
    // some fields omitted
}

A direct isometry, i.e., a rotation followed by a translation.

Fields

rotation: R

The pure rotational part of this isometry.

translation: TranslationBase<N, D, S>

The pure translational part of this isometry.

Methods

impl<N, D: DimName, S, R> IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn from_parts(
    translation: TranslationBase<N, D, S>,
    rotation: R
) -> IsometryBase<N, D, S, R>

Creates a new isometry from its rotational and translational parts.

fn inverse(&self) -> IsometryBase<N, D, S, R>

Inverts self.

fn inverse_mut(&mut self)

Inverts self.

fn append_translation_mut(&mut self, t: &TranslationBase<N, D, S>)

Appends to self the given translation in-place.

fn append_rotation_mut(&mut self, r: &R)

Appends to self the given rotation in-place.

fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &PointBase<N, D, S>)

Appends in-place to self a rotation centered at the point p, i.e., the rotation that lets p invariant.

fn append_rotation_wrt_center_mut(&mut self, r: &R)

Appends in-place to self a rotation centered at the point with coordinates self.translation.

impl<N, D: DimName, S, R> IsometryBase<N, D, S, R> where
    N: Scalar,
    S: Storage<N, D, U1>, 

fn to_homogeneous(&self) -> OwnedSquareMatrix<N, DimNameSum<D, U1>, S::Alloc> where
    D: DimNameAdd<U1>,
    R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, S::Alloc>>,
    S::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

Converts this isometry into its equivalent homogeneous transformation matrix.

impl<N, D: DimName, S, R> IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: AlgaRotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn identity() -> Self

Creates a new identity isometry.

impl<N, D: DimName, S, R> IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: AlgaRotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn rotation_wrt_point(r: R, p: PointBase<N, D, S>) -> Self

The isometry that applies the rotation r with its axis passing through the point p. This effectively lets p invariant.

impl<N, S, SR> IsometryBase<N, U2, S, RotationBase<N, U2, SR>> where
    N: Real,
    S: OwnedStorage<N, U2, U1, Alloc = SR::Alloc>,
    SR: OwnedStorage<N, U2, U2>,
    S::Alloc: OwnedAllocator<N, U2, U1, S>,
    SR::Alloc: OwnedAllocator<N, U2, U2, SR>, 

fn new(translation: ColumnVector<N, U2, S>, angle: N) -> Self

Creates a new isometry from a translation and a rotation angle.

impl<N, S> IsometryBase<N, U2, S, UnitComplex<N>> where
    N: Real,
    S: OwnedStorage<N, U2, U1>,
    S::Alloc: OwnedAllocator<N, U2, U1, S>, 

fn new(translation: ColumnVector<N, U2, S>, angle: N) -> Self

Creates a new isometry from a translation and a rotation angle.

impl<N, S, SR> IsometryBase<N, U3, S, RotationBase<N, U3, SR>> where
    N: Real,
    S: OwnedStorage<N, U3, U1, Alloc = SR::Alloc>,
    SR: OwnedStorage<N, U3, U3>,
    S::Alloc: OwnedAllocator<N, U3, U1, S>,
    SR::Alloc: OwnedAllocator<N, U3, U3, SR> + Allocator<N, U3, U3>, 

fn new(
    translation: ColumnVector<N, U3, S>,
    axisangle: ColumnVector<N, U3, S>
) -> Self

Creates a new isometry from a translation and a rotation axis-angle.

fn new_observer_frame(
    eye: &PointBase<N, U3, S>,
    target: &PointBase<N, U3, S>,
    up: &ColumnVector<N, U3, S>
) -> Self

Creates an isometry that corresponds to the local frame of an observer standing at the point eye and looking toward target.

It maps the view direction target - eye to the positive z axis and the origin to the eye.

Arguments

• eye - The observer position.
• target - The target position.
• up - Vertical direction. The only requirement of this parameter is to not be collinear to eye - at. Non-collinearity is not checked.

fn look_at_rh(
    eye: &PointBase<N, U3, S>,
    target: &PointBase<N, U3, S>,
    up: &ColumnVector<N, U3, S>
) -> Self

Builds a right-handed look-at view matrix.

This conforms to the common notion of right handed look-at matrix from the computer graphics community.

Arguments

• eye - The eye position.
• target - The target position.
• up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to target - eye.

fn look_at_lh(
    eye: &PointBase<N, U3, S>,
    target: &PointBase<N, U3, S>,
    up: &ColumnVector<N, U3, S>
) -> Self

Builds a left-handed look-at view matrix.

This conforms to the common notion of left handed look-at matrix from the computer graphics community.

Arguments

• eye - The eye position.
• target - The target position.
• up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to target - eye.

impl<N, S, SR> IsometryBase<N, U3, S, UnitQuaternionBase<N, SR>> where
    N: Real,
    S: OwnedStorage<N, U3, U1, Alloc = SR::Alloc>,
    SR: OwnedStorage<N, U4, U1>,
    S::Alloc: OwnedAllocator<N, U3, U1, S>,
    SR::Alloc: OwnedAllocator<N, U4, U1, SR> + Allocator<N, U3, U3>, 

fn new(
    translation: ColumnVector<N, U3, S>,
    axisangle: ColumnVector<N, U3, S>
) -> Self

Creates a new isometry from a translation and a rotation axis-angle.

fn new_observer_frame(
    eye: &PointBase<N, U3, S>,
    target: &PointBase<N, U3, S>,
    up: &ColumnVector<N, U3, S>
) -> Self

Creates an isometry that corresponds to the local frame of an observer standing at the point eye and looking toward target.

It maps the view direction target - eye to the positive z axis and the origin to the eye.

Arguments

• eye - The observer position.
• target - The target position.
• up - Vertical direction. The only requirement of this parameter is to not be collinear to eye - at. Non-collinearity is not checked.

fn look_at_rh(
    eye: &PointBase<N, U3, S>,
    target: &PointBase<N, U3, S>,
    up: &ColumnVector<N, U3, S>
) -> Self

Builds a right-handed look-at view matrix.

This conforms to the common notion of right handed look-at matrix from the computer graphics community.

Arguments

• eye - The eye position.
• target - The target position.
• up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to target - eye.

fn look_at_lh(
    eye: &PointBase<N, U3, S>,
    target: &PointBase<N, U3, S>,
    up: &ColumnVector<N, U3, S>
) -> Self

Builds a left-handed look-at view matrix.

This conforms to the common notion of left handed look-at matrix from the computer graphics community.

Arguments

• eye - The eye position.
• target - The target position.
• up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to target - eye.

Trait Implementations

impl<N: Hash + Scalar, D: Hash + DimName, S: Hash, R: Hash> Hash for IsometryBase<N, D, S, R>

fn hash<__HNDSR: Hasher>(&self, __arg_0: &mut __HNDSR)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<N: Debug + Scalar, D: Debug + DimName, S: Debug, R: Debug> Debug for IsometryBase<N, D, S, R>

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

Formats the value using the given formatter.

impl<N: Clone + Scalar, D: Clone + DimName, S: Clone, R: Clone> Clone for IsometryBase<N, D, S, R>

fn clone(&self) -> IsometryBase<N, D, S, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy + Scalar, D: Copy + DimName, S: Copy, R: Copy> Copy for IsometryBase<N, D, S, R>

impl<N, D: DimName, S, R> Eq for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>> + Eq,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

impl<N, D: DimName, S, R> PartialEq for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>> + PartialEq,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn eq(&self, right: &IsometryBase<N, D, S, R>) -> 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: DimName, S, R> ApproxEq for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>> + ApproxEq<Epsilon = N::Epsilon>,
    S::Alloc: OwnedAllocator<N, D, U1, S>,
    N::Epsilon: Copy, 

type Epsilon = N::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn relative_ne(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N, D: DimName, S, R> Display for IsometryBase<N, D, S, R> where
    N: Real + Display,
    S: OwnedStorage<N, D, U1>,
    R: Display,
    S::Alloc: OwnedAllocator<N, D, U1, S> + Allocator<usize, D, U1>, 

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

Formats the value using the given formatter.

impl<N, D: DimName, S, R> One for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: AlgaRotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn one() -> Self

Creates a new identity isometry.

impl<N, D: DimName, S, R> Rand for IsometryBase<N, D, S, R> where
    N: Real + Rand,
    S: OwnedStorage<N, D, U1>,
    R: AlgaRotation<PointBase<N, D, S>> + Rand,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn rand<G: Rng>(rng: &mut G) -> Self

Generates a random instance of this type using the specified source of randomness.

impl<N, D: DimName, S, R> Mul<IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, N, D: DimName, S, R> Mul<IsometryBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'b, N, D: DimName, S, R> Mul<&'b IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, 'b, N, D: DimName, S, R> Mul<&'b IsometryBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<N, D: DimName, S, R> Div<IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<'a, N, D: DimName, S, R> Div<IsometryBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<'b, N, D: DimName, S, R> Div<&'b IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<'a, 'b, N, D: DimName, S, R> Div<&'b IsometryBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<N, D: DimName, S, R> MulAssign<TranslationBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

The method for the *= operator

impl<'b, N, D: DimName, S, R> MulAssign<&'b TranslationBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

The method for the *= operator

impl<N, D: DimName, S, R> MulAssign<IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

The method for the *= operator

impl<'b, N, D: DimName, S, R> MulAssign<&'b IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

The method for the *= operator

impl<N, D: DimName, S, R> DivAssign<IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn div_assign(&mut self, rhs: IsometryBase<N, D, S, R>)

The method for the /= operator

impl<'b, N, D: DimName, S, R> DivAssign<&'b IsometryBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

The method for the /= operator

impl<N, D: DimName, S, R> MulAssign<R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn mul_assign(&mut self, rhs: R)

The method for the *= operator

impl<'b, N, D: DimName, S, R> MulAssign<&'b R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn mul_assign(&mut self, rhs: &'b R)

The method for the *= operator

impl<N, D: DimName, S, R> DivAssign<R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn div_assign(&mut self, rhs: R)

The method for the /= operator

impl<'b, N, D: DimName, S, R> DivAssign<&'b R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn div_assign(&mut self, rhs: &'b R)

The method for the /= operator

impl<N, D: DimName, S, R> Mul<R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, N, D: DimName, S, R> Mul<R> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'b, N, D: DimName, S, R> Mul<&'b R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

fn mul(self, rhs: &'b R) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimName, S, R> Mul<&'b R> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

fn mul(self, rhs: &'b R) -> Self::Output

The method for the * operator

impl<N, D: DimName, S, R> Div<R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

fn div(self, rhs: R) -> Self::Output

The method for the / operator

impl<'a, N, D: DimName, S, R> Div<R> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

fn div(self, rhs: R) -> Self::Output

The method for the / operator

impl<'b, N, D: DimName, S, R> Div<&'b R> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

fn div(self, rhs: &'b R) -> Self::Output

The method for the / operator

impl<'a, 'b, N, D: DimName, S, R> Div<&'b R> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the / operator

fn div(self, rhs: &'b R) -> Self::Output

The method for the / operator

impl<N, D: DimName, S, R> Mul<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = PointBase<N, D, S>

The resulting type after applying the * operator

fn mul(self, right: PointBase<N, D, S>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimName, S, R> Mul<PointBase<N, D, S>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = PointBase<N, D, S>

The resulting type after applying the * operator

fn mul(self, right: PointBase<N, D, S>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimName, S, R> Mul<&'b PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = PointBase<N, D, S>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, 'b, N, D: DimName, S, R> Mul<&'b PointBase<N, D, S>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = PointBase<N, D, S>

The resulting type after applying the * operator

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

The method for the * operator

impl<N, D: DimName, S, R> Mul<ColumnVector<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = ColumnVector<N, D, S>

The resulting type after applying the * operator

fn mul(self, right: ColumnVector<N, D, S>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimName, S, R> Mul<ColumnVector<N, D, S>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = ColumnVector<N, D, S>

The resulting type after applying the * operator

fn mul(self, right: ColumnVector<N, D, S>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimName, S, R> Mul<&'b ColumnVector<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = ColumnVector<N, D, S>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, 'b, N, D: DimName, S, R> Mul<&'b ColumnVector<N, D, S>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = ColumnVector<N, D, S>

The resulting type after applying the * operator

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

The method for the * operator

impl<N, D: DimName, S, R> Mul<TranslationBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

fn mul(self, right: TranslationBase<N, D, S>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimName, S, R> Mul<TranslationBase<N, D, S>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

fn mul(self, right: TranslationBase<N, D, S>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimName, S, R> Mul<&'b TranslationBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, 'b, N, D: DimName, S, R> Mul<&'b TranslationBase<N, D, S>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = IsometryBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<N, D: DimName, S, R> Identity<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

fn identity() -> Self

The identity element.

impl<N, D: DimName, S, R> Inverse<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, 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: DimName, S, R> AbstractMagma<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, 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: DimName, S, R> AbstractSemigroup<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, 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: DimName, S, R> AbstractMonoid<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, 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: DimName, S, R> AbstractQuasigroup<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, 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: DimName, S, R> AbstractLoop<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

impl<N, D: DimName, S, R> AbstractGroup<Multiplicative> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

impl<N, D: DimName, S, R> Transformation<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

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

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

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

impl<N, D: DimName, S, R> ProjectiveTransformation<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

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

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

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

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

impl<N, D: DimName, S, R> AffineTransformation<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Rotation = R

Type of the first rotation to be applied.

type NonUniformScaling = Id

Type of the non-uniform scaling to be applied.

type Translation = TranslationBase<N, D, S>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (TranslationBase<N, D, S>, R, Id, R)

Decomposes this affine transformation into a rotation followed by a non-uniform scaling, followed by a rotation, followed by a translation.

fn append_translation(&self, t: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, t: &Self::Translation) -> Self

Prepends a translation to this similarity.

fn append_rotation(&self, r: &Self::Rotation) -> Self

Appends a rotation to this similarity.

fn prepend_rotation(&self, r: &Self::Rotation) -> Self

Prepends a rotation to this similarity.

fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self

Appends a scaling factor to this similarity.

fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self

Prepends a scaling factor to this similarity.

fn append_rotation_wrt_point(
    &self,
    r: &Self::Rotation,
    p: &PointBase<N, D, S>
) -> Option<Self>

Appends to this similarity a rotation centered at the point p, i.e., this point is left invariant.

impl<N, D: DimName, S, R> Similarity<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Scaling = Id

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(&self) -> TranslationBase<N, D, S>

The pure translational component of this similarity transformation.

fn rotation(&self) -> R

The pure rotational component of this similarity transformation.

fn scaling(&self) -> Id

The pure scaling component of this similarity transformation.

fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

fn rotate_point(&self, pt: &E) -> E

Applies this transformation's pure rotational part to a point.

fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation's pure rotational part to a vector.

fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation's pure scaling part to a vector.

fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

fn inverse_scale_point(&self, pt: &E) -> E

Applies this transformation inverse's pure scaling part to a point.

fn inverse_rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation inverse's pure rotational part to a vector.

fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation inverse's pure scaling part to a vector.

impl<N, D: DimName, S, R> Isometry<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

impl<N, D: DimName, S, R> DirectIsometry<PointBase<N, D, S>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

impl<N1, N2, D: DimName, SA, SB, R1, R2> SubsetOf<IsometryBase<N2, D, SB, R2>> for IsometryBase<N1, D, SA, R1> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    R1: Rotation<PointBase<N1, D, SA>> + SubsetOf<R2>,
    R2: Rotation<PointBase<N2, D, SB>>,
    SA: OwnedStorage<N1, D, U1>,
    SB: OwnedStorage<N2, D, U1>,
    SA::Alloc: OwnedAllocator<N1, D, U1, SA>,
    SB::Alloc: OwnedAllocator<N2, D, U1, SB>, 

fn to_superset(&self) -> IsometryBase<N2, D, SB, R2>

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

fn is_in_subset(iso: &IsometryBase<N2, D, SB, R2>) -> bool

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

unsafe fn from_superset_unchecked(iso: &IsometryBase<N2, D, SB, R2>) -> 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, R1, R2> SubsetOf<SimilarityBase<N2, D, SB, R2>> for IsometryBase<N1, D, SA, R1> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    R1: Rotation<PointBase<N1, D, SA>> + SubsetOf<R2>,
    R2: Rotation<PointBase<N2, D, SB>>,
    SA: OwnedStorage<N1, D, U1>,
    SB: OwnedStorage<N2, D, U1>,
    SA::Alloc: OwnedAllocator<N1, D, U1, SA>,
    SB::Alloc: OwnedAllocator<N2, D, U1, SB>, 

fn to_superset(&self) -> SimilarityBase<N2, D, SB, R2>

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

fn is_in_subset(sim: &SimilarityBase<N2, D, SB, R2>) -> bool

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

unsafe fn from_superset_unchecked(sim: &SimilarityBase<N2, D, SB, R2>) -> 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, SA, SB, R, C> SubsetOf<TransformBase<N2, D, SB, C>> for IsometryBase<N1, D, SA, R> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    SA: OwnedStorage<N1, D, U1>,
    SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    C: SuperTCategoryOf<TAffine>,
    R: Rotation<PointBase<N1, D, SA>> + SubsetOf<OwnedSquareMatrix<N1, DimNameSum<D, U1>, SA::Alloc>> + SubsetOf<SquareMatrix<N2, DimNameSum<D, U1>, SB>>,
    D: DimNameAdd<U1>,
    SA::Alloc: OwnedAllocator<N1, D, U1, SA> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB> + Allocator<N2, D, D> + Allocator<N2, D, U1> + Allocator<N2, U1, D>, 

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

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

fn is_in_subset(t: &TransformBase<N2, D, SB, C>) -> 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, C>) -> 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, SA, SB, R> SubsetOf<SquareMatrix<N2, DimNameSum<D, U1>, SB>> for IsometryBase<N1, D, SA, R> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    SA: OwnedStorage<N1, D, U1>,
    SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    R: Rotation<PointBase<N1, D, SA>> + SubsetOf<OwnedSquareMatrix<N1, DimNameSum<D, U1>, SA::Alloc>> + SubsetOf<SquareMatrix<N2, DimNameSum<D, U1>, SB>>,
    D: DimNameAdd<U1>,
    SA::Alloc: OwnedAllocator<N1, D, U1, SA> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB> + Allocator<N2, D, D> + Allocator<N2, D, U1> + Allocator<N2, U1, D>, 

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.

impl<N, D: DimName, S, R> Mul<SimilarityBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, N, D: DimName, S, R> Mul<SimilarityBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'b, N, D: DimName, S, R> Mul<&'b SimilarityBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, 'b, N, D: DimName, S, R> Mul<&'b SimilarityBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the * operator

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

The method for the * operator

impl<N, D: DimName, S, R> Div<SimilarityBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<'a, N, D: DimName, S, R> Div<SimilarityBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<'b, N, D: DimName, S, R> Div<&'b SimilarityBase<N, D, S, R>> for IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<'a, 'b, N, D: DimName, S, R> Div<&'b SimilarityBase<N, D, S, R>> for &'a IsometryBase<N, D, S, R> where
    N: Real,
    S: OwnedStorage<N, D, U1>,
    R: Rotation<PointBase<N, D, S>>,
    S::Alloc: OwnedAllocator<N, D, U1, S>, 

type Output = SimilarityBase<N, D, S, R>

The resulting type after applying the / operator

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

The method for the / operator

impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SA::Alloc>>, SA, SB> Mul<TransformBase<N, D, SB, C>> for IsometryBase<N, D, SA, R> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, D, U1>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::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: TransformBase<N, D, SB, C>) -> Self::Output

The method for the * operator

impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SA::Alloc>>, SA, SB> Mul<TransformBase<N, D, SB, C>> for &'a IsometryBase<N, D, SA, R> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, D, U1>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::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: TransformBase<N, D, SB, C>) -> Self::Output

The method for the * operator

impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SA::Alloc>>, SA, SB> Mul<&'b TransformBase<N, D, SB, C>> for IsometryBase<N, D, SA, R> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, D, U1>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::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 TransformBase<N, D, SB, C>) -> Self::Output

The method for the * operator

impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<OwnedSquareMatrix<N, DimNameSum<D, U1>, SA::Alloc>>, SA, SB> Mul<&'b TransformBase<N, D, SB, C>> for &'a IsometryBase<N, D, SA, R> where
    N: Scalar + Zero + ClosedAdd + ClosedMul + Real,
    SA: Storage<N, D, U1>,
    SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
    SA::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 TransformBase<N, D, SB, C>) -> Self::Output

The method for the * operator