Type Definition nalgebra::geometry::UnitQuaternion

type UnitQuaternion<N> = Unit<Quaternion<N>>;

A unit quaternions. May be used to represent a rotation.

Methods

impl<N: Real> UnitQuaternion<N>

pub fn into_owned(self) -> UnitQuaternion<N>

Deprecated

: This method is a no-op and will be removed in a future release.

Moves this unit quaternion into one that owns its data.

pub fn clone_owned(&self) -> UnitQuaternion<N>

Deprecated

: This method is a no-op and will be removed in a future release.

Clones this unit quaternion into one that owns its data.

pub fn angle(&self) -> N

The rotation angle in [0; pi] of this unit quaternion.

pub fn quaternion(&self) -> &Quaternion<N>

The underlying quaternion.

Same as self.as_ref().

pub fn conjugate(&self) -> UnitQuaternion<N>

Compute the conjugate of this unit quaternion.

pub fn inverse(&self) -> UnitQuaternion<N>

Inverts this quaternion if it is not zero.

pub fn angle_to(&self, other: &UnitQuaternion<N>) -> N

The rotation angle needed to make self and other coincide.

pub fn rotation_to(&self, other: &UnitQuaternion<N>) -> UnitQuaternion<N>

The unit quaternion needed to make self and other coincide.

The result is such that: self.rotation_to(other) * self == other.

pub fn lerp(&self, other: &UnitQuaternion<N>, t: N) -> Quaternion<N>

Linear interpolation between two unit quaternions.

The result is not normalized.

pub fn nlerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>

Normalized linear interpolation between two unit quaternions.

pub fn slerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>

Spherical linear interpolation between two unit quaternions.

Panics if the angle between both quaternion is 180 degrees (in which case the interpolation is not well-defined).

pub fn try_slerp(     &self,     other: &UnitQuaternion<N>,     t: N,     epsilon: N ) -> Option<UnitQuaternion<N>>

Computes the spherical linear interpolation between two unit quaternions or returns None if both quaternions are approximately 180 degrees apart (in which case the interpolation is not well-defined).

Arguments

• self: the first quaternion to interpolate from.
• other: the second quaternion to interpolate toward.
• t: the interpolation parameter. Should be between 0 and 1.
• epsilon: the value below which the sinus of the angle separating both quaternion must be to return None.

pub fn conjugate_mut(&mut self)

Compute the conjugate of this unit quaternion in-place.

pub fn inverse_mut(&mut self)

Inverts this quaternion if it is not zero.

pub fn axis(&self) -> Option<Unit<Vector3<N>>>

The rotation axis of this unit quaternion or None if the rotation is zero.

pub fn scaled_axis(&self) -> Vector3<N>

The rotation axis of this unit quaternion multiplied by the rotation agle.

pub fn axis_angle(&self) -> Option<(Unit<Vector3<N>>, N)>

The rotation axis and angle in ]0, pi] of this unit quaternion.

Returns None if the angle is zero.

pub fn exp(&self) -> Quaternion<N>

Compute the exponential of a quaternion.

Note that this function yields a Quaternion<N> because it looses the unit property.

pub fn ln(&self) -> Quaternion<N>

Compute the natural logarithm of a quaternion.

Note that this function yields a Quaternion<N> because it looses the unit property. The vector part of the return value corresponds to the axis-angle representation (divided by 2.0) of this unit quaternion.

pub fn powf(&self, n: N) -> UnitQuaternion<N>

Raise the quaternion to a given floating power.

This returns the unit quaternion that identifies a rotation with axis self.axis() and angle self.angle() × n.

pub fn to_rotation_matrix(&self) -> Rotation<N, U3>

Builds a rotation matrix from this unit quaternion.

pub fn to_euler_angles(&self) -> (N, N, N)

Converts this unit quaternion into its equivalent Euler angles.

The angles are produced in the form (roll, yaw, pitch).

pub fn to_homogeneous(&self) -> MatrixN<N, U4>

Converts this unit quaternion into its equivalent homogeneous transformation matrix.

impl<N: Real> UnitQuaternion<N>

pub fn identity() -> Self

The quaternion multiplicative identity.

pub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Self where     SB: Storage<N, U3>,

Creates a new quaternion from a unit vector (the rotation axis) and an angle (the rotation angle).

pub fn from_quaternion(q: Quaternion<N>) -> Self

Creates a new unit quaternion from a quaternion.

The input quaternion will be normalized.

pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self

Creates a new unit quaternion from Euler angles.

The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.

pub fn from_rotation_matrix(rotmat: &Rotation<N, U3>) -> Self

Builds an unit quaternion from a rotation matrix.

pub fn rotation_between<SB, SC>(     a: &Vector<N, U3, SB>,     b: &Vector<N, U3, SC> ) -> Option<Self> where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

The unit quaternion needed to make a and b be collinear and point toward the same direction.

pub fn scaled_rotation_between<SB, SC>(     a: &Vector<N, U3, SB>,     b: &Vector<N, U3, SC>,     s: N ) -> Option<Self> where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

The smallest rotation needed to make a and b collinear and point toward the same direction, raised to the power s.

pub fn rotation_between_axis<SB, SC>(     a: &Unit<Vector<N, U3, SB>>,     b: &Unit<Vector<N, U3, SC>> ) -> Option<Self> where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

The unit quaternion needed to make a and b be collinear and point toward the same direction.

pub fn scaled_rotation_between_axis<SB, SC>(     na: &Unit<Vector<N, U3, SB>>,     nb: &Unit<Vector<N, U3, SC>>,     s: N ) -> Option<Self> where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

The smallest rotation needed to make a and b collinear and point toward the same direction, raised to the power s.

pub fn new_observer_frame<SB, SC>(     dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC> ) -> Self where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

Creates an unit quaternion that corresponds to the local frame of an observer standing at the origin and looking toward dir.

It maps the view direction dir to the positive z axis.

Arguments

• dir - The look direction, that is, direction the matrix z axis will be aligned with.
• up - The vertical direction. The only requirement of this parameter is to not be collinear to dir. Non-collinearity is not checked.

pub fn look_at_rh<SB, SC>(     dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC> ) -> Self where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

Builds a right-handed look-at view matrix without translation.

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.

pub fn look_at_lh<SB, SC>(     dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC> ) -> Self where     SB: Storage<N, U3>,     SC: Storage<N, U3>,

Builds a left-handed look-at view matrix without translation.

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.

pub fn new<SB>(axisangle: Vector<N, U3, SB>) -> Self where     SB: Storage<N, U3>,

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If axisangle has a magnitude smaller than N::default_epsilon(), this returns the identity rotation.

pub fn new_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self where     SB: Storage<N, U3>,

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If axisangle has a magnitude smaller than eps, this returns the identity rotation.

pub fn from_scaled_axis<SB>(axisangle: Vector<N, U3, SB>) -> Self where     SB: Storage<N, U3>,

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If axisangle has a magnitude smaller than N::default_epsilon(), this returns the identity rotation. Same as Self::new(axisangle).

pub fn from_scaled_axis_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self where     SB: Storage<N, U3>,

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If axisangle has a magnitude smaller than eps, this returns the identity rotation. Same as Self::new(axisangle).

Trait Implementations

impl<N1, N2> SubsetOf<UnitQuaternion<N2>> for Rotation3<N1> where     N1: Real,     N2: Real + SupersetOf<N1>,

fn to_superset(&self) -> UnitQuaternion<N2>

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

fn is_in_subset(q: &UnitQuaternion<N2>) -> bool

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

unsafe fn from_superset_unchecked(q: &UnitQuaternion<N2>) -> 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: Real + Display> Display for UnitQuaternion<N>

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

Formats the value using the given formatter.

impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N>

type Epsilon = N

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

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

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

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

The inverse of ApproxEq::abs_diff_eq.

impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq for UnitQuaternion<N>

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for 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 relative_ne(     &self,     other: &Self,     epsilon: Self::Epsilon,     max_relative: Self::Epsilon ) -> bool

The inverse of ApproxEq::relative_eq.

impl<N: Real + UlpsEq<Epsilon = N>> UlpsEq for UnitQuaternion<N>

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that 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 ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N: Real> One for UnitQuaternion<N>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where     Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

impl<N: Real> Distribution<UnitQuaternion<N>> for Standard where     OpenClosed01: Distribution<N>,

fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> UnitQuaternion<N>

Generate a uniformly distributed random rotation quaternion.

Important traits for DistIter<'a, D, R, T>

impl<'a, D, R, T> Iterator for DistIter<'a, D, R, T> where
    D: Distribution<T>,
    R: Rng + 'a,  type Item = T;

fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where     R: Rng,

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<'a, 'b, N: Real> Mul<&'b UnitQuaternion<N>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: Real> Mul<UnitQuaternion<N>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, N: Real> Mul<&'b UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real> Mul<UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N: Real> Div<&'b UnitQuaternion<N>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, N: Real> Div<UnitQuaternion<N>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b, N: Real> Div<&'b UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<N: Real> Div<UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, N: Real> Mul<&'b Rotation<N, U3>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: Real> Mul<Rotation<N, U3>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Rotation<N, U3>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real> Mul<Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Rotation<N, U3>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Div<&'b Rotation<N, U3>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, N: Real> Div<Rotation<N, U3>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: Rotation<N, U3>) -> Self::Output

Performs the / operation.

impl<'b, N: Real> Div<&'b Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<N: Real> Div<Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: Rotation<N, U3>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: Real> Mul<&'b UnitQuaternion<N>> for &'a Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: Real> Mul<UnitQuaternion<N>> for &'a Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, N: Real> Mul<&'b UnitQuaternion<N>> for Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real> Mul<UnitQuaternion<N>> for Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N: Real> Div<&'b UnitQuaternion<N>> for &'a Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, N: Real> Div<UnitQuaternion<N>> for &'a Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b, N: Real> Div<&'b UnitQuaternion<N>> for Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<N: Real> Div<UnitQuaternion<N>> for Rotation<N, U3> where     DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, N: Real, SB: Storage<N, U3>> Mul<&'b Vector<N, U3, SB>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Vector3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: Real, SB: Storage<N, U3>> Mul<Vector<N, U3, SB>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Vector3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, N: Real, SB: Storage<N, U3>> Mul<&'b Vector<N, U3, SB>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Vector3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real, SB: Storage<N, U3>> Mul<Vector<N, U3, SB>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Vector3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Point3<N>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Point3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: Real> Mul<Point3<N>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Point3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, N: Real> Mul<&'b Point3<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Point3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real> Mul<Point3<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Point3<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N: Real, SB: Storage<N, U3>> Mul<&'b Unit<Vector<N, U3, SB>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: Real, SB: Storage<N, U3>> Mul<Unit<Vector<N, U3, SB>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U3, SB>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real, SB: Storage<N, U3>> Mul<&'b Unit<Vector<N, U3, SB>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real, SB: Storage<N, U3>> Mul<Unit<Vector<N, U3, SB>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U3, SB>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> MulAssign<&'b UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

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

Performs the *= operation.

impl<N: Real> MulAssign<UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

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

Performs the *= operation.

impl<'b, N: Real> DivAssign<&'b UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

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

Performs the /= operation.

impl<N: Real> DivAssign<UnitQuaternion<N>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,

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

Performs the /= operation.

impl<'b, N: Real> MulAssign<&'b Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

fn mul_assign(&mut self, rhs: &'b Rotation<N, U3>)

Performs the *= operation.

impl<N: Real> MulAssign<Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

fn mul_assign(&mut self, rhs: Rotation<N, U3>)

Performs the *= operation.

impl<'b, N: Real> DivAssign<&'b Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

fn div_assign(&mut self, rhs: &'b Rotation<N, U3>)

Performs the /= operation.

impl<N: Real> DivAssign<Rotation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,

fn div_assign(&mut self, rhs: Rotation<N, U3>)

Performs the /= operation.

impl<N: Real> Identity<Multiplicative> for UnitQuaternion<N>

fn identity() -> Self

The identity element.

fn id(O) -> Self

Specific identity.

impl<N: Real> AbstractMagma<Multiplicative> for UnitQuaternion<N>

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

Performs an operation.

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

Performs specific operation.

impl<N: Real> Inverse<Multiplicative> for UnitQuaternion<N>

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: Real> AbstractSemigroup<Multiplicative> for UnitQuaternion<N>

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

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: Real> AbstractQuasigroup<Multiplicative> for UnitQuaternion<N>

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

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: Real> AbstractMonoid<Multiplicative> for UnitQuaternion<N>

fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where     Self: RelativeEq,

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(args: (Self,)) -> bool where     Self: Eq,

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

impl<N: Real> AbstractLoop<Multiplicative> for UnitQuaternion<N>

impl<N: Real> AbstractGroup<Multiplicative> for UnitQuaternion<N>

impl<N: Real> Transformation<Point3<N>> for UnitQuaternion<N>

fn transform_point(&self, pt: &Point3<N>) -> Point3<N>

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

fn transform_vector(&self, v: &Vector3<N>) -> Vector3<N>

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

impl<N: Real> ProjectiveTransformation<Point3<N>> for UnitQuaternion<N>

fn inverse_transform_point(&self, pt: &Point3<N>) -> Point3<N>

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

fn inverse_transform_vector(&self, v: &Vector3<N>) -> Vector3<N>

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

impl<N: Real> AffineTransformation<Point3<N>> for UnitQuaternion<N>

type Rotation = Self

Type of the first rotation to be applied.

type NonUniformScaling = Id

Type of the non-uniform scaling to be applied.

type Translation = Id

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

fn decompose(&self) -> (Id, Self, Id, Self)

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, _: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, _: &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: &E) -> Option<Self>

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

impl<N: Real> Similarity<Point3<N>> for UnitQuaternion<N>

type Scaling = Id

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

fn translation(&self) -> Id

The pure translational component of this similarity transformation.

fn rotation(&self) -> Self

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: Real> Isometry<Point3<N>> for UnitQuaternion<N>

impl<N: Real> DirectIsometry<Point3<N>> for UnitQuaternion<N>

impl<N: Real> OrthogonalTransformation<Point3<N>> for UnitQuaternion<N>

impl<N: Real> Rotation<Point3<N>> for UnitQuaternion<N>

fn powf(&self, n: N) -> Option<Self>

Raises this rotation to a power. If this is a simple rotation, the result must be equivalent to multiplying the rotation angle by n.

fn rotation_between(a: &Vector3<N>, b: &Vector3<N>) -> Option<Self>

Computes a simple rotation that makes the angle between a and b equal to zero, i.e., b.angle(a * delta_rotation(a, b)) = 0. If a and b are collinear, the computed rotation may not be unique. Returns None if no such simple rotation exists in the subgroup represented by Self.

fn scaled_rotation_between(a: &Vector3<N>, b: &Vector3<N>, s: N) -> Option<Self>

Computes the rotation between a and b and raises it to the power n.

impl<N1, N2> SubsetOf<UnitQuaternion<N2>> for UnitQuaternion<N1> where     N1: Real,     N2: Real + SupersetOf<N1>,

fn to_superset(&self) -> UnitQuaternion<N2>

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

fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool

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

unsafe fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> 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> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1> where     N1: Real,     N2: Real + SupersetOf<N1>,

fn to_superset(&self) -> Rotation3<N2>

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

fn is_in_subset(rot: &Rotation3<N2>) -> bool

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

unsafe fn from_superset_unchecked(rot: &Rotation3<N2>) -> 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, R> SubsetOf<Isometry<N2, U3, R>> for UnitQuaternion<N1> where     N1: Real,     N2: Real + SupersetOf<N1>,     R: AlgaRotation<Point3<N2>> + SupersetOf<UnitQuaternion<N1>>,

fn to_superset(&self) -> Isometry<N2, U3, R>

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

fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool

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

unsafe fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> 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, R> SubsetOf<Similarity<N2, U3, R>> for UnitQuaternion<N1> where     N1: Real,     N2: Real + SupersetOf<N1>,     R: AlgaRotation<Point3<N2>> + SupersetOf<UnitQuaternion<N1>>,

fn to_superset(&self) -> Similarity<N2, U3, R>

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

fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool

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

unsafe fn from_superset_unchecked(sim: &Similarity<N2, U3, R>) -> 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, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1> where     N1: Real,     N2: Real + SupersetOf<N1>,     C: SuperTCategoryOf<TAffine>,

fn to_superset(&self) -> Transform<N2, U3, C>

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

fn is_in_subset(t: &Transform<N2, U3, C>) -> bool

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

unsafe fn from_superset_unchecked(t: &Transform<N2, U3, 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: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix4<N2>> for UnitQuaternion<N1>

fn to_superset(&self) -> Matrix4<N2>

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

fn is_in_subset(m: &Matrix4<N2>) -> bool

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

unsafe fn from_superset_unchecked(m: &Matrix4<N2>) -> 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: Real> Mul<Translation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: Translation<N, U3>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Translation<N, U3>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: Translation<N, U3>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Translation<N, U3>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Translation<N, U3>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Translation<N, U3>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Translation<N, U3>) -> Self::Output

Performs the * operation.

impl<N: Real> Mul<Isometry<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Isometry<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Isometry<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Isometry<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<N: Real> Div<Isometry<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<'a, N: Real> Div<Isometry<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<'b, N: Real> Div<&'b Isometry<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: Real> Div<&'b Isometry<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<N: Real> Mul<UnitQuaternion<N>> for Translation<N, U3> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<UnitQuaternion<N>> for &'a Translation<N, U3> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b UnitQuaternion<N>> for Translation<N, U3> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b UnitQuaternion<N>> for &'a Translation<N, U3> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real> Mul<Similarity<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Similarity<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Similarity<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Similarity<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the * operation.

impl<N: Real> Div<Similarity<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<'a, N: Real> Div<Similarity<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<'b, N: Real> Div<&'b Similarity<N, U3, UnitQuaternion<N>>> for UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: Real> Div<&'b Similarity<N, U3, UnitQuaternion<N>>> for &'a UnitQuaternion<N> where     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,

type Output = Similarity<N, U3, UnitQuaternion<N>>

The resulting type after applying the / operator.

fn div(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output

Performs the / operation.

impl<N, C: TCategoryMul<TAffine>> Mul<UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N, C: TCategoryMul<TAffine>> Mul<UnitQuaternion<N>> for &'a Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, N, C: TCategoryMul<TAffine>> Mul<&'b UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N, C: TCategoryMul<TAffine>> Mul<&'b UnitQuaternion<N>> for &'a Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N, C: TCategoryMul<TAffine>> Mul<Transform<N, U3, C>> for UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, U3, C>) -> Self::Output

Performs the * operation.

impl<'a, N, C: TCategoryMul<TAffine>> Mul<Transform<N, U3, C>> for &'a UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, U3, C>) -> Self::Output

Performs the * operation.

impl<'b, N, C: TCategoryMul<TAffine>> Mul<&'b Transform<N, U3, C>> for UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Transform<N, U3, C>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, C: TCategoryMul<TAffine>> Mul<&'b Transform<N, U3, C>> for &'a UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Transform<N, U3, C>) -> Self::Output

Performs the * operation.

impl<N, C: TCategoryMul<TAffine>> Div<UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, N, C: TCategoryMul<TAffine>> Div<UnitQuaternion<N>> for &'a Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b, N, C: TCategoryMul<TAffine>> Div<&'b UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, N, C: TCategoryMul<TAffine>> Div<&'b UnitQuaternion<N>> for &'a Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<N, C: TCategoryMul<TAffine>> Div<Transform<N, U3, C>> for UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: Transform<N, U3, C>) -> Self::Output

Performs the / operation.

impl<'a, N, C: TCategoryMul<TAffine>> Div<Transform<N, U3, C>> for &'a UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: Transform<N, U3, C>) -> Self::Output

Performs the / operation.

impl<'b, N, C: TCategoryMul<TAffine>> Div<&'b Transform<N, U3, C>> for UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Transform<N, U3, C>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N, C: TCategoryMul<TAffine>> Div<&'b Transform<N, U3, C>> for &'a UnitQuaternion<N> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>,

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Transform<N, U3, C>) -> Self::Output

Performs the / operation.

impl<N, C: TCategory> MulAssign<UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,

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

Performs the *= operation.

impl<'b, N, C: TCategory> MulAssign<&'b UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,

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

Performs the *= operation.

impl<N, C: TCategory> DivAssign<UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,

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

Performs the /= operation.

impl<'b, N, C: TCategory> DivAssign<&'b UnitQuaternion<N>> for Transform<N, U3, C> where     N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,     DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,

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

Performs the /= operation.