[][src]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>
[src]

Deprecated

: This method is unnecessary and will be removed in a future release. Use .clone() instead.

Moves this unit quaternion into one that owns its data.

Deprecated

: This method is unnecessary and will be removed in a future release. Use .clone() instead.

Clones this unit quaternion into one that owns its data.

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

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = UnitQuaternion::from_axis_angle(&axis, 1.78);
assert_eq!(rot.angle(), 1.78);

The underlying quaternion.

Same as self.as_ref().

Example

let axis = UnitQuaternion::identity();
assert_eq!(*axis.quaternion(), Quaternion::new(1.0, 0.0, 0.0, 0.0));

Compute the conjugate of this unit quaternion.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = UnitQuaternion::from_axis_angle(&axis, 1.78);
let conj = rot.conjugate();
assert_eq!(conj, UnitQuaternion::from_axis_angle(&-axis, 1.78));

Inverts this quaternion if it is not zero.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = UnitQuaternion::from_axis_angle(&axis, 1.78);
let inv = rot.inverse();
assert_eq!(rot * inv, UnitQuaternion::identity());
assert_eq!(inv * rot, UnitQuaternion::identity());

The rotation angle needed to make self and other coincide.

Example

let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);

The unit quaternion needed to make self and other coincide.

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

Example

let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
let rot_to = rot1.rotation_to(&rot2);
assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6);

Linear interpolation between two unit quaternions.

The result is not normalized.

Example

let q1 = UnitQuaternion::new_normalize(Quaternion::new(1.0, 0.0, 0.0, 0.0));
let q2 = UnitQuaternion::new_normalize(Quaternion::new(0.0, 1.0, 0.0, 0.0));
assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(0.9, 0.1, 0.0, 0.0));

Normalized linear interpolation between two unit quaternions.

This is the same as self.lerp except that the result is normalized.

Example

let q1 = UnitQuaternion::new_normalize(Quaternion::new(1.0, 0.0, 0.0, 0.0));
let q2 = UnitQuaternion::new_normalize(Quaternion::new(0.0, 1.0, 0.0, 0.0));
assert_eq!(q1.nlerp(&q2, 0.1), UnitQuaternion::new_normalize(Quaternion::new(0.9, 0.1, 0.0, 0.0)));

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). Use .try_slerp instead to avoid the panic.

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.

Compute the conjugate of this unit quaternion in-place.

Inverts this quaternion if it is not zero.

Example

let axisangle = Vector3::new(0.1, 0.2, 0.3);
let mut rot = UnitQuaternion::new(axisangle);
rot.inverse_mut();
assert_relative_eq!(rot * UnitQuaternion::new(axisangle), UnitQuaternion::identity());
assert_relative_eq!(UnitQuaternion::new(axisangle) * rot, UnitQuaternion::identity());

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

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = UnitQuaternion::from_axis_angle(&axis, angle);
assert_eq!(rot.axis(), Some(axis));

// Case with a zero angle.
let rot = UnitQuaternion::from_axis_angle(&axis, 0.0);
assert!(rot.axis().is_none());

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

Example

let axisangle = Vector3::new(0.1, 0.2, 0.3);
let rot = UnitQuaternion::new(axisangle);
assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);

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

Returns None if the angle is zero.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = UnitQuaternion::from_axis_angle(&axis, angle);
assert_eq!(rot.axis_angle(), Some((axis, angle)));

// Case with a zero angle.
let rot = UnitQuaternion::from_axis_angle(&axis, 0.0);
assert!(rot.axis_angle().is_none());

Compute the exponential of a quaternion.

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

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.

Example

let axisangle = Vector3::new(0.1, 0.2, 0.3);
let q = UnitQuaternion::new(axisangle);
assert_relative_eq!(q.ln().vector().into_owned(), axisangle, epsilon = 1.0e-6);

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.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = UnitQuaternion::from_axis_angle(&axis, angle);
let pow = rot.powf(2.0);
assert_relative_eq!(pow.axis().unwrap(), axis, epsilon = 1.0e-6);
assert_eq!(pow.angle(), 2.4);

Builds a rotation matrix from this unit quaternion.

Example

let q = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let rot = q.to_rotation_matrix();
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);

assert_relative_eq!(*rot.matrix(), expected, epsilon = 1.0e-6);

Deprecated

: This is renamed to use .euler_angles().

Converts this unit quaternion into its equivalent Euler angles.

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

Retrieves the euler angles corresponding to this unit quaternion.

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

Example

let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
let euler = rot.euler_angles();
assert_relative_eq!(euler.0, 0.1, epsilon = 1.0e-6);
assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);

Converts this unit quaternion into its equivalent homogeneous transformation matrix.

Example

let rot = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let expected = Matrix4::new(0.8660254, -0.5,      0.0, 0.0,
                            0.5,       0.8660254, 0.0, 0.0,
                            0.0,       0.0,       1.0, 0.0,
                            0.0,       0.0,       0.0, 1.0);

assert_relative_eq!(rot.to_homogeneous(), expected, epsilon = 1.0e-6);

impl<N: Real> UnitQuaternion<N>
[src]

The rotation identity.

Example

let q = UnitQuaternion::identity();
let q2 = UnitQuaternion::new(Vector3::new(1.0, 2.0, 3.0));
let v = Vector3::new_random();
let p = Point3::from(v);

assert_eq!(q * q2, q2);
assert_eq!(q2 * q, q2);
assert_eq!(q * v, v);
assert_eq!(q * p, p);

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

Example

let axis = Vector3::y_axis();
let angle = f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::from_axis_angle(&axis, angle);

assert_eq!(q.axis().unwrap(), axis);
assert_eq!(q.angle(), angle);
assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(UnitQuaternion::from_scaled_axis(Vector3::<f32>::zeros()), UnitQuaternion::identity());

Creates a new unit quaternion from a quaternion.

The input quaternion will be normalized.

Creates a new unit quaternion from Euler angles.

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

Example

let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
let euler = rot.euler_angles();
assert_relative_eq!(euler.0, 0.1, epsilon = 1.0e-6);
assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);

Builds an unit quaternion from a rotation matrix.

Example

let axis = Vector3::y_axis();
let angle = 0.1;
let rot = Rotation3::from_axis_angle(&axis, angle);
let q = UnitQuaternion::from_rotation_matrix(&rot);
assert_relative_eq!(q.to_rotation_matrix(), rot, epsilon = 1.0e-6);
assert_relative_eq!(q.axis().unwrap(), rot.axis().unwrap(), epsilon = 1.0e-6);
assert_relative_eq!(q.angle(), rot.angle(), epsilon = 1.0e-6);

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

Example

let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let q = UnitQuaternion::rotation_between(&a, &b).unwrap();
assert_relative_eq!(q * a, b);
assert_relative_eq!(q.inverse() * b, a);

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

Example

let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let q2 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.2).unwrap();
let q5 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.5).unwrap();
assert_relative_eq!(q2 * q2 * q2 * q2 * q2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(q5 * q5 * a, b, epsilon = 1.0e-6);

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

Example

let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
let q = UnitQuaternion::rotation_between(&a, &b).unwrap();
assert_relative_eq!(q * a, b);
assert_relative_eq!(q.inverse() * b, a);

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

Example

let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
let q2 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.2).unwrap();
let q5 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.5).unwrap();
assert_relative_eq!(q2 * q2 * q2 * q2 * q2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(q5 * q5 * a, b, epsilon = 1.0e-6);

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

It maps the z axis to the direction dir.

Arguments

  • dir - The look direction. It does not need to be normalized.
  • up - The vertical direction. It does not need to be normalized. The only requirement of this parameter is to not be collinear to dir. Non-collinearity is not checked.

Example

let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let q = UnitQuaternion::face_towards(&dir, &up);
assert_relative_eq!(q * Vector3::z(), dir.normalize());

Deprecated

: renamed to face_towards

Deprecated: Use [UnitQuaternion::face_towards] instead.

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

It maps the view direction dir to the negative z axis. This conforms to the common notion of right handed look-at matrix from the computer graphics community.

Arguments

  • dir − The view direction. It does not need to be normalized.
  • up - A vector approximately aligned with required the vertical axis. It does not need to be normalized. The only requirement of this parameter is to not be collinear to dir.

Example

let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let q = UnitQuaternion::look_at_rh(&dir, &up);
assert_relative_eq!(q * dir.normalize(), -Vector3::z());

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

It maps the view direction dir to the positive z axis. This conforms to the common notion of left handed look-at matrix from the computer graphics community.

Arguments

  • dir − The view direction. It does not need to be normalized.
  • up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to dir.

Example

let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let q = UnitQuaternion::look_at_lh(&dir, &up);
assert_relative_eq!(q * dir.normalize(), Vector3::z());

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.

Example

let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::new(axisangle);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(UnitQuaternion::new(Vector3::<f32>::zeros()), UnitQuaternion::identity());

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.

Example

let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::new_eps(axisangle, 1.0e-6);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// An almost zero vector yields an identity.
assert_eq!(UnitQuaternion::new_eps(Vector3::new(1.0e-8, 1.0e-9, 1.0e-7), 1.0e-6), UnitQuaternion::identity());

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).

Example

let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::from_scaled_axis(axisangle);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(UnitQuaternion::from_scaled_axis(Vector3::<f32>::zeros()), UnitQuaternion::identity());

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_eps(axisangle, eps).

Example

let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::from_scaled_axis_eps(axisangle, 1.0e-6);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// An almost zero vector yields an identity.
assert_eq!(UnitQuaternion::from_scaled_axis_eps(Vector3::new(1.0e-8, 1.0e-9, 1.0e-7), 1.0e-6), UnitQuaternion::identity());

Trait Implementations

impl<N: Real + Display> Display for UnitQuaternion<N>
[src]

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

The resulting type after applying the * operator.

impl<'a, N: Real> Mul<Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

The resulting type after applying the * operator.

impl<'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

The resulting type after applying the * operator.

impl<N: Real> Mul<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<N: Real, SB: Storage<N, U3>> Mul<Matrix<N, U3, U1, SB>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<N: Real> Mul<Point<N, U3>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

impl<N: Real> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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

The resulting type after applying the * operator.

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>, 
[src]

The resulting type after applying the * operator.

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>, 
[src]

The resulting type after applying the * operator.

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>, 
[src]

The resulting type after applying the * operator.

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>, 
[src]

The resulting type after applying the * operator.

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

The resulting type after applying the / operator.

impl<'a, N: Real> Div<Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

The resulting type after applying the / operator.

impl<'b, N: Real> Div<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

The resulting type after applying the / operator.

impl<N: Real> Div<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

impl<N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 
[src]

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

impl<N: Real> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 
[src]

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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

The resulting type after applying the / operator.

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>, 
[src]

The resulting type after applying the / operator.

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>, 
[src]

The resulting type after applying the / operator.

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>, 
[src]

The resulting type after applying the / operator.

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>, 
[src]

The resulting type after applying the / operator.

impl<'b, N: Real> MulAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

impl<N: Real> MulAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

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

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

impl<'b, N: Real> DivAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

impl<N: Real> DivAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>, 
[src]

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

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

impl<N: Real + Arbitrary> Arbitrary for UnitQuaternion<N> where
    Owned<N, U4>: Send,
    Owned<N, U3>: Send
[src]

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

Used for specifying relative comparisons.

The inverse of ApproxEq::abs_diff_eq.

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

The inverse of ApproxEq::relative_eq.

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

The inverse of ApproxEq::ulps_eq.

impl<N: Real> One for UnitQuaternion<N>
[src]

Returns true if self is equal to the multiplicative identity. Read more

impl<N: Real> AbstractMagma<Multiplicative> for UnitQuaternion<N>
[src]

Performs specific operation.

impl<N: Real> AbstractQuasigroup<Multiplicative> for UnitQuaternion<N>
[src]

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

Returns true if latin squareness holds for the given arguments. Read more

impl<N: Real> AbstractSemigroup<Multiplicative> for UnitQuaternion<N>
[src]

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

Returns true if associativity holds for the given arguments.

impl<N: Real> AbstractLoop<Multiplicative> for UnitQuaternion<N>
[src]

impl<N: Real> AbstractMonoid<Multiplicative> for UnitQuaternion<N>
[src]

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

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

impl<N: Real> AbstractGroup<Multiplicative> for UnitQuaternion<N>
[src]

impl<N: Real> TwoSidedInverse<Multiplicative> for UnitQuaternion<N>
[src]

impl<N: Real> Identity<Multiplicative> for UnitQuaternion<N>
[src]

Specific identity.

impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for UnitQuaternion<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 
[src]

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

impl<N1, N2> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 
[src]

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

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>>, 
[src]

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

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>>, 
[src]

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

impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    C: SuperTCategoryOf<TAffine>, 
[src]

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

impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for UnitQuaternion<N1>
[src]

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

impl<N: Real> Transformation<Point<N, U3>> for UnitQuaternion<N>
[src]

impl<N: Real> ProjectiveTransformation<Point<N, U3>> for UnitQuaternion<N>
[src]

impl<N: Real> AffineTransformation<Point<N, U3>> for UnitQuaternion<N>
[src]

Type of the first rotation to be applied.

Type of the non-uniform scaling to be applied.

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

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

impl<N: Real> Similarity<Point<N, U3>> for UnitQuaternion<N>
[src]

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

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

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

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

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

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

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

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

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

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

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

impl<N: Real> Isometry<Point<N, U3>> for UnitQuaternion<N>
[src]

impl<N: Real> DirectIsometry<Point<N, U3>> for UnitQuaternion<N>
[src]

impl<N: Real> OrthogonalTransformation<Point<N, U3>> for UnitQuaternion<N>
[src]

impl<N: Real> Rotation<Point<N, U3>> for UnitQuaternion<N>
[src]