Struct nalgebra::geometry::Quaternion [−][src]
#[repr(C)]pub struct Quaternion<T> {
pub coords: Vector4<T>,
}
Expand description
A quaternion. See the type alias UnitQuaternion = Unit<Quaternion>
for a quaternion
that may be used as a rotation.
Fields
coords: Vector4<T>
This quaternion as a 4D vector of coordinates in the [ x, y, z, w ]
storage order.
Implementations
👎 Deprecated: This method is a no-op and will be removed in a future release.
This method is a no-op and will be removed in a future release.
Moves this unit quaternion into one that owns its data.
👎 Deprecated: This method is a no-op and will be removed in a future release.
This method is a no-op and will be removed in a future release.
Clones this unit quaternion into one that owns its data.
Normalizes this quaternion.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let q_normalized = q.normalize();
relative_eq!(q_normalized.norm(), 1.0);
The conjugate of this quaternion.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let conj = q.conjugate();
assert!(conj.i == -2.0 && conj.j == -3.0 && conj.k == -4.0 && conj.w == 1.0);
Linear interpolation between two quaternion.
Computes self * (1 - t) + other * t
.
Example
let q1 = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let q2 = Quaternion::new(10.0, 20.0, 30.0, 40.0);
assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(1.9, 3.8, 5.7, 7.6));
The vector part (i, j, k)
of this quaternion.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_eq!(q.vector()[0], 2.0);
assert_eq!(q.vector()[1], 3.0);
assert_eq!(q.vector()[2], 4.0);
The scalar part w
of this quaternion.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_eq!(q.scalar(), 1.0);
Reinterprets this quaternion as a 4D vector.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
// Recall that the quaternion is stored internally as (i, j, k, w)
// while the crate::new constructor takes the arguments as (w, i, j, k).
assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
The norm of this quaternion.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6);
A synonym for the norm of this quaternion.
Aka the length.
This is the same as .norm()
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6);
The squared norm of this quaternion.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_eq!(q.magnitude_squared(), 30.0);
A synonym for the squared norm of this quaternion.
Aka the squared length.
This is the same as .norm_squared()
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_eq!(q.magnitude_squared(), 30.0);
Inverts this quaternion if it is not zero.
This method also does not works with SIMD components (see simd_try_inverse
instead).
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let inv_q = q.try_inverse();
assert!(inv_q.is_some());
assert_relative_eq!(inv_q.unwrap() * q, Quaternion::identity());
//Non-invertible case
let q = Quaternion::new(0.0, 0.0, 0.0, 0.0);
let inv_q = q.try_inverse();
assert!(inv_q.is_none());
Attempt to inverse this quaternion.
This method also works with SIMD components.
Calculates the inner product (also known as the dot product). See “Foundations of Game Engine Development, Volume 1: Mathematics” by Lengyel Formula 4.89.
Example
let a = Quaternion::new(0.0, 2.0, 3.0, 4.0);
let b = Quaternion::new(0.0, 5.0, 2.0, 1.0);
let expected = Quaternion::new(-20.0, 0.0, 0.0, 0.0);
let result = a.inner(&b);
assert_relative_eq!(expected, result, epsilon = 1.0e-5);
Calculates the outer product (also known as the wedge product). See “Foundations of Game Engine Development, Volume 1: Mathematics” by Lengyel Formula 4.89.
Example
let a = Quaternion::new(0.0, 2.0, 3.0, 4.0);
let b = Quaternion::new(0.0, 5.0, 2.0, 1.0);
let expected = Quaternion::new(0.0, -5.0, 18.0, -11.0);
let result = a.outer(&b);
assert_relative_eq!(expected, result, epsilon = 1.0e-5);
Calculates the projection of self
onto other
(also known as the parallel).
See “Foundations of Game Engine Development, Volume 1: Mathematics” by Lengyel
Formula 4.94.
Example
let a = Quaternion::new(0.0, 2.0, 3.0, 4.0);
let b = Quaternion::new(0.0, 5.0, 2.0, 1.0);
let expected = Quaternion::new(0.0, 3.333333333333333, 1.3333333333333333, 0.6666666666666666);
let result = a.project(&b).unwrap();
assert_relative_eq!(expected, result, epsilon = 1.0e-5);
Calculates the rejection of self
from other
(also known as the perpendicular).
See “Foundations of Game Engine Development, Volume 1: Mathematics” by Lengyel
Formula 4.94.
Example
let a = Quaternion::new(0.0, 2.0, 3.0, 4.0);
let b = Quaternion::new(0.0, 5.0, 2.0, 1.0);
let expected = Quaternion::new(0.0, -1.3333333333333333, 1.6666666666666665, 3.3333333333333335);
let result = a.reject(&b).unwrap();
assert_relative_eq!(expected, result, epsilon = 1.0e-5);
The polar decomposition of this quaternion.
Returns, from left to right: the quaternion norm, the half rotation angle, the rotation
axis. If the rotation angle is zero, the rotation axis is set to None
.
Example
let q = Quaternion::new(0.0, 5.0, 0.0, 0.0);
let (norm, half_ang, axis) = q.polar_decomposition();
assert_eq!(norm, 5.0);
assert_eq!(half_ang, f32::consts::FRAC_PI_2);
assert_eq!(axis, Some(Vector3::x_axis()));
Compute the natural logarithm of a quaternion.
Example
let q = Quaternion::new(2.0, 5.0, 0.0, 0.0);
assert_relative_eq!(q.ln(), Quaternion::new(1.683647, 1.190289, 0.0, 0.0), epsilon = 1.0e-6)
Compute the exponential of a quaternion.
Example
let q = Quaternion::new(1.683647, 1.190289, 0.0, 0.0);
assert_relative_eq!(q.exp(), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5)
Compute the exponential of a quaternion. Returns the identity if the vector part of this quaternion
has a norm smaller than eps
.
Example
let q = Quaternion::new(1.683647, 1.190289, 0.0, 0.0);
assert_relative_eq!(q.exp_eps(1.0e-6), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5);
// Singular case.
let q = Quaternion::new(0.0000001, 0.0, 0.0, 0.0);
assert_eq!(q.exp_eps(1.0e-6), Quaternion::identity());
Raise the quaternion to a given floating power.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert_relative_eq!(q.powf(1.5), Quaternion::new( -6.2576659, 4.1549037, 6.2323556, 8.3098075), epsilon = 1.0e-6);
Transforms this quaternion into its 4D vector form (Vector part, Scalar part).
Example
let mut q = Quaternion::identity();
*q.as_vector_mut() = Vector4::new(1.0, 2.0, 3.0, 4.0);
assert!(q.i == 1.0 && q.j == 2.0 && q.k == 3.0 && q.w == 4.0);
The mutable vector part (i, j, k)
of this quaternion.
Example
let mut q = Quaternion::identity();
{
let mut v = q.vector_mut();
v[0] = 2.0;
v[1] = 3.0;
v[2] = 4.0;
}
assert!(q.i == 2.0 && q.j == 3.0 && q.k == 4.0 && q.w == 1.0);
Replaces this quaternion by its conjugate.
Example
let mut q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
q.conjugate_mut();
assert!(q.i == -2.0 && q.j == -3.0 && q.k == -4.0 && q.w == 1.0);
Inverts this quaternion in-place if it is not zero.
Example
let mut q = Quaternion::new(1.0f32, 2.0, 3.0, 4.0);
assert!(q.try_inverse_mut());
assert_relative_eq!(q * Quaternion::new(1.0, 2.0, 3.0, 4.0), Quaternion::identity());
//Non-invertible case
let mut q = Quaternion::new(0.0f32, 0.0, 0.0, 0.0);
assert!(!q.try_inverse_mut());
Normalizes this quaternion.
Example
let mut q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
q.normalize_mut();
assert_relative_eq!(q.norm(), 1.0);
Check if the quaternion is pure.
A quaternion is pure if it has no real part (self.w == 0.0
).
Left quaternionic division.
Calculates B-1 * A where A = self, B = other.
Right quaternionic division.
Calculates A * B-1 where A = self, B = other.
Example
let a = Quaternion::new(0.0, 1.0, 2.0, 3.0);
let b = Quaternion::new(0.0, 5.0, 2.0, 1.0);
let result = a.right_div(&b).unwrap();
let expected = Quaternion::new(0.4, 0.13333333333333336, -0.4666666666666667, 0.26666666666666666);
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the quaternionic cosinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(58.93364616794395, -34.086183690465596, -51.1292755356984, -68.17236738093119);
let result = input.cos();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the quaternionic arccosinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let result = input.cos().acos();
assert_relative_eq!(input, result, epsilon = 1.0e-7);
Calculates the quaternionic sinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(91.78371578403467, 21.886486853029176, 32.82973027954377, 43.77297370605835);
let result = input.sin();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the quaternionic arcsinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let result = input.sin().asin();
assert_relative_eq!(input, result, epsilon = 1.0e-7);
Calculates the quaternionic tangent.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(0.00003821631725009489, 0.3713971716439371, 0.5570957574659058, 0.7427943432878743);
let result = input.tan();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the quaternionic arctangent.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let result = input.tan().atan();
assert_relative_eq!(input, result, epsilon = 1.0e-7);
Calculates the hyperbolic quaternionic sinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(0.7323376060463428, -0.4482074499805421, -0.6723111749708133, -0.8964148999610843);
let result = input.sinh();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the hyperbolic quaternionic arcsinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(2.385889902585242, 0.514052600662788, 0.7710789009941821, 1.028105201325576);
let result = input.asinh();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the hyperbolic quaternionic cosinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(0.9615851176369566, -0.3413521745610167, -0.5120282618415251, -0.6827043491220334);
let result = input.cosh();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the hyperbolic quaternionic arccosinus.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(2.4014472020074007, 0.5162761016176176, 0.7744141524264264, 1.0325522032352352);
let result = input.acosh();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the hyperbolic quaternionic tangent.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(1.0248695360556623, -0.10229568178876419, -0.1534435226831464, -0.20459136357752844);
let result = input.tanh();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Calculates the hyperbolic quaternionic arctangent.
Example
let input = Quaternion::new(1.0, 2.0, 3.0, 4.0);
let expected = Quaternion::new(0.03230293287000163, 0.5173453683196951, 0.7760180524795426, 1.0346907366393903);
let result = input.atanh();
assert_relative_eq!(expected, result, epsilon = 1.0e-7);
Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the w
vector component.
Creates a new quaternion from its individual components. Note that the arguments order does not follow the storage order.
The storage order is [ i, j, k, w ]
while the arguments for this functions are in the
order (w, i, j, k)
.
Example
let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
assert!(q.i == 2.0 && q.j == 3.0 && q.k == 4.0 && q.w == 1.0);
assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
Cast the components of self
to another type.
Example
let q = Quaternion::new(1.0f64, 2.0, 3.0, 4.0);
let q2 = q.cast::<f32>();
assert_eq!(q2, Quaternion::new(1.0f32, 2.0, 3.0, 4.0));
Creates a new quaternion from its scalar and vector parts. Note that the arguments order does not follow the storage order.
The storage order is [ vector, scalar ].
Example
let w = 1.0;
let ijk = Vector3::new(2.0, 3.0, 4.0);
let q = Quaternion::from_parts(w, ijk);
assert!(q.i == 2.0 && q.j == 3.0 && q.k == 4.0 && q.w == 1.0);
assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
Trait Implementations
type Epsilon = T
type Epsilon = T
Used for specifying relative comparisons.
The default tolerance to use when testing values that are close together. Read more
A test for equality that uses the absolute difference to compute the approximate equality of two numbers. Read more
The inverse of AbsDiffEq::abs_diff_eq
.
impl<'a, 'b, T: SimdRealField> Add<&'b Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
impl<'a, 'b, T: SimdRealField> Add<&'b Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
impl<'b, T: SimdRealField> Add<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<'b, T: SimdRealField> Add<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
impl<'a, T: SimdRealField> Add<Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
impl<'a, T: SimdRealField> Add<Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
impl<'b, T: SimdRealField> AddAssign<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<'b, T: SimdRealField> AddAssign<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
Performs the +=
operation. Read more
impl<T: SimdRealField> AddAssign<Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<T: SimdRealField> AddAssign<Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
Performs the +=
operation. Read more
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error> where
Des: Deserializer<'a>,
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error> where
Des: Deserializer<'a>,
Deserialize this value from the given Serde deserializer. Read more
Performs the /=
operation. Read more
impl<T: Scalar> From<Matrix<T, Const<{ typenum::$D::USIZE }>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T>
impl<T: Scalar> From<Matrix<T, Const<{ typenum::$D::USIZE }>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T>
impl<'a, 'b, T: SimdRealField> Mul<&'b Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
impl<'a, 'b, T: SimdRealField> Mul<&'b Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
impl<'b, T: SimdRealField> Mul<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<'b, T: SimdRealField> Mul<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
type Output = Quaternion<f32>
type Output = Quaternion<f32>
The resulting type after applying the *
operator.
type Output = Quaternion<f64>
type Output = Quaternion<f64>
The resulting type after applying the *
operator.
impl<'a, T: SimdRealField> Mul<Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
impl<'a, T: SimdRealField> Mul<Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
type Output = Quaternion<f32>
type Output = Quaternion<f32>
The resulting type after applying the *
operator.
type Output = Quaternion<f64>
type Output = Quaternion<f64>
The resulting type after applying the *
operator.
impl<'b, T: SimdRealField> MulAssign<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<'b, T: SimdRealField> MulAssign<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
Performs the *=
operation. Read more
impl<T: SimdRealField> MulAssign<Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<T: SimdRealField> MulAssign<Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
Performs the *=
operation. Read more
Performs the *=
operation. Read more
type Norm = T::SimdRealField
type Norm = T::SimdRealField
The type of the norm.
Computes the norm.
Computes the squared norm.
Divides self
by n.
The default relative tolerance for testing values that are far-apart. Read more
A test for equality that uses a relative comparison if the values are far apart.
The inverse of RelativeEq::relative_eq
.
type Element = Quaternion<T::Element>
type Element = Quaternion<T::Element>
The type of the elements of each lane of this SIMD value.
Extracts the i-th lane of self
without bound-checking.
Replaces the i-th lane of self
by val
. Read more
Replaces the i-th lane of self
by val
without bound-checking.
Merges self
and other
depending on the lanes of cond
. Read more
Applies a function to each lane of self
. Read more
impl<'a, 'b, T: SimdRealField> Sub<&'b Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
impl<'a, 'b, T: SimdRealField> Sub<&'b Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
impl<'b, T: SimdRealField> Sub<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<'b, T: SimdRealField> Sub<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
impl<'a, T: SimdRealField> Sub<Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
impl<'a, T: SimdRealField> Sub<Quaternion<T>> for &'a Quaternion<T> where
T::Element: SimdRealField,
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
impl<'b, T: SimdRealField> SubAssign<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<'b, T: SimdRealField> SubAssign<&'b Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
Performs the -=
operation. Read more
impl<T: SimdRealField> SubAssign<Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
impl<T: SimdRealField> SubAssign<Quaternion<T>> for Quaternion<T> where
T::Element: SimdRealField,
Performs the -=
operation. Read more
impl<T1, T2> SubsetOf<Quaternion<T2>> for Quaternion<T1> where
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
impl<T1, T2> SubsetOf<Quaternion<T2>> for Quaternion<T1> where
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
The inclusion map: converts self
to the equivalent element of its superset.
Checks if element
is actually part of the subset Self
(and can be converted to it).
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
The default ULPs to tolerate when testing values that are far-apart. Read more
A test for equality that uses units in the last place (ULP) if the values are far apart.
Auto Trait Implementations
impl<T> RefUnwindSafe for Quaternion<T> where
T: RefUnwindSafe,
impl<T> Send for Quaternion<T> where
T: Send,
impl<T> Sync for Quaternion<T> where
T: Sync,
impl<T> Unpin for Quaternion<T> where
T: Unpin,
impl<T> UnwindSafe for Quaternion<T> where
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
Checks if self
is actually part of its subset T
(and can be converted to it).
Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
The inclusion map: converts self
to the equivalent element of its superset.