Struct bevy_rapier2d::prelude::nalgebra::Quaternion [−][src]
#[repr(C)]pub struct Quaternion<T> { pub coords: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>, }
Expand description
A quaternion. See the type alias UnitQuaternion = Unit<Quaternion>
for a quaternion
that may be used as a rotation.
Fields
coords: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
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 imaginary part of this quaternion.
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));
pub fn vector(
&self
) -> Matrix<T, Const<{_: usize}>, Const<1_usize>, SliceStorage<'_, T, Const<{_: usize}>, Const<1_usize>, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::RStride, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::CStride>>
[src]
pub fn vector(
&self
) -> Matrix<T, Const<{_: usize}>, Const<1_usize>, SliceStorage<'_, T, Const<{_: usize}>, Const<1_usize>, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::RStride, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::CStride>>
[src]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);
The dot product of two quaternions.
Example
let q1 = Quaternion::new(1.0, 2.0, 3.0, 4.0); let q2 = Quaternion::new(5.0, 6.0, 7.0, 8.0); assert_eq!(q1.dot(&q2), 70.0);
#[must_use = "Did you mean to use try_inverse_mut()?"]pub fn try_inverse(&self) -> Option<Quaternion<T>> where
T: RealField,
[src]
#[must_use = "Did you mean to use try_inverse_mut()?"]pub fn try_inverse(&self) -> Option<Quaternion<T>> where
T: RealField,
[src]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());
#[must_use = "Did you mean to use try_inverse_mut()?"]pub fn simd_try_inverse(&self) -> SimdOption<Quaternion<T>>
[src]
#[must_use = "Did you mean to use try_inverse_mut()?"]pub fn simd_try_inverse(&self) -> SimdOption<Quaternion<T>>
[src]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);
pub fn as_vector_mut(
&mut self
) -> &mut Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
[src]
pub fn as_vector_mut(
&mut self
) -> &mut Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
[src]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);
pub fn vector_mut(
&mut self
) -> Matrix<T, Const<{_: usize}>, Const<1_usize>, SliceStorageMut<'_, T, Const<{_: usize}>, Const<1_usize>, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::RStride, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::CStride>>
[src]
pub fn vector_mut(
&mut self
) -> Matrix<T, Const<{_: usize}>, Const<1_usize>, SliceStorageMut<'_, T, Const<{_: usize}>, Const<1_usize>, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::RStride, <<DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<1_usize>>>::Buffer as Storage<T, Const<{_: usize}>, Const<1_usize>>>::CStride>>
[src]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);
Calculates square of a quaternion.
Divides quaternion into two.
Calculates square root.
Check if the quaternion is pure.
A quaternion is pure if it has no real part (self.w == 0.0
).
Convert quaternion to pure quaternion.
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);
pub const fn from_vector(
vector: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
) -> Quaternion<T>
[src]
pub const fn from_vector(
vector: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
) -> Quaternion<T>
[src]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));
pub fn from_imag(
vector: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Quaternion<T>
[src]
pub fn from_imag(
vector: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Quaternion<T>
[src]Constructs a pure quaternion.
pub fn from_parts<SB>(
scalar: T,
vector: Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>
) -> Quaternion<T> where
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
[src]
pub fn from_parts<SB>(
scalar: T,
vector: Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>
) -> Quaternion<T> where
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
[src]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));
Constructs a real quaternion.
The quaternion multiplicative identity.
Example
let q = Quaternion::identity(); let q2 = Quaternion::new(1.0, 2.0, 3.0, 4.0); assert_eq!(q * q2, q2); assert_eq!(q2 * q, q2);
pub fn from_polar_decomposition<SB>(
scale: T,
theta: T,
axis: Unit<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>>
) -> Quaternion<T> where
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
[src]
pub fn from_polar_decomposition<SB>(
scale: T,
theta: T,
axis: Unit<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>>
) -> Quaternion<T> where
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
[src]Creates a new quaternion from its polar decomposition.
Note that axis
is assumed to be a unit vector.
Trait Implementations
impl<T> AbsDiffEq<Quaternion<T>> for Quaternion<T> where
T: RealField<Epsilon = T> + AbsDiffEq<T>,
[src]
impl<T> AbsDiffEq<Quaternion<T>> for Quaternion<T> where
T: RealField<Epsilon = T> + AbsDiffEq<T>,
[src]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
pub fn abs_diff_eq(
&self,
other: &Quaternion<T>,
epsilon: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon
) -> bool
[src]
pub fn abs_diff_eq(
&self,
other: &Quaternion<T>,
epsilon: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon
) -> bool
[src]A test for equality that uses the absolute difference to compute the approximate equality of two numbers. Read more
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
The inverse of [AbsDiffEq::abs_diff_eq
].
impl<'b, T> Add<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'b, T> Add<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
impl<'a, 'b, T> Add<&'b Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, 'b, T> Add<&'b Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
pub fn add(
self,
rhs: &'b Quaternion<T>
) -> <&'a Quaternion<T> as Add<&'b Quaternion<T>>>::Output
[src]
pub fn add(
self,
rhs: &'b Quaternion<T>
) -> <&'a Quaternion<T> as Add<&'b Quaternion<T>>>::Output
[src]Performs the +
operation. Read more
impl<'a, T> Add<Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, T> Add<Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
impl<T> Add<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Add<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the +
operator.
Performs the +
operation. Read more
impl<'b, T> AddAssign<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'b, T> AddAssign<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the +=
operation. Read more
impl<T> AddAssign<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> AddAssign<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the +=
operation. Read more
Returns the “default value” for a type. Read more
Mutably dereferences the value.
impl<'a, T> Div<T> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, T> Div<T> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the /
operator.
impl<T> Div<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Div<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the /
operator.
impl<T> DivAssign<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> DivAssign<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the /=
operation. Read more
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
Performs the conversion.
impl<T> From<Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T> where
T: Scalar,
[src]
impl<T> From<Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T> where
T: Scalar,
[src]pub fn from(
coords: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
) -> Quaternion<T>
[src]
pub fn from(
coords: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
) -> Quaternion<T>
[src]Performs the conversion.
Performs the conversion.
impl<'a, 'b, T> Mul<&'b Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, 'b, T> Mul<&'b Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: &'b Quaternion<T>
) -> <&'a Quaternion<T> as Mul<&'b Quaternion<T>>>::Output
[src]
pub fn mul(
self,
rhs: &'b Quaternion<T>
) -> <&'a Quaternion<T> as Mul<&'b Quaternion<T>>>::Output
[src]Performs the *
operation. Read more
impl<'b, T> Mul<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'b, T> Mul<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
impl<T> Mul<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Mul<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
impl<'a, T> Mul<Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, T> Mul<Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
Performs the *
operation. Read more
impl<'a, T> Mul<T> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, T> Mul<T> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
impl<T> Mul<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Mul<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the *
operator.
impl<'b, T> MulAssign<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'b, T> MulAssign<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the *=
operation. Read more
impl<T> MulAssign<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> MulAssign<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the *=
operation. Read more
impl<T> MulAssign<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> MulAssign<T> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the *=
operation. Read more
impl<T> Neg for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Neg for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
impl<'a, T> Neg for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, T> Neg for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
type Norm = <T as SimdComplexField>::SimdRealField
type Norm = <T as SimdComplexField>::SimdRealField
The type of the norm.
Computes the norm.
Computes the squared norm.
Multiply self
by n.
Divides self
by n.
impl<T> One for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> One for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Returns the multiplicative identity element of Self
, 1
. Read more
impl<T> RelativeEq<Quaternion<T>> for Quaternion<T> where
T: RealField<Epsilon = T> + RelativeEq<T>,
[src]
impl<T> RelativeEq<Quaternion<T>> for Quaternion<T> where
T: RealField<Epsilon = T> + RelativeEq<T>,
[src]The default relative tolerance for testing values that are far-apart. Read more
pub fn relative_eq(
&self,
other: &Quaternion<T>,
epsilon: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon,
max_relative: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon
) -> bool
[src]
pub fn relative_eq(
&self,
other: &Quaternion<T>,
epsilon: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon,
max_relative: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon
) -> bool
[src]A test for equality that uses a relative comparison if the values are far apart.
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of [RelativeEq::relative_eq
].
type Element = Quaternion<<T as SimdValue>::Element>
type Element = Quaternion<<T as SimdValue>::Element>
The type of the elements of each lane of this SIMD value.
Type of the result of comparing two SIMD values like self
.
Initializes an SIMD value with each lanes set to val
.
Extracts the i-th lane of self
. Read more
Extracts the i-th lane of self
without bound-checking.
Replaces the i-th lane of self
by val
. Read more
pub unsafe fn replace_unchecked(
&mut self,
i: usize,
val: <Quaternion<T> as SimdValue>::Element
)
[src]
pub unsafe fn replace_unchecked(
&mut self,
i: usize,
val: <Quaternion<T> as SimdValue>::Element
)
[src]Replaces the i-th lane of self
by val
without bound-checking.
pub fn select(
self,
cond: <Quaternion<T> as SimdValue>::SimdBool,
other: Quaternion<T>
) -> Quaternion<T>
[src]
pub fn select(
self,
cond: <Quaternion<T> as SimdValue>::SimdBool,
other: Quaternion<T>
) -> Quaternion<T>
[src]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> Sub<&'b Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, 'b, T> Sub<&'b Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
pub fn sub(
self,
rhs: &'b Quaternion<T>
) -> <&'a Quaternion<T> as Sub<&'b Quaternion<T>>>::Output
[src]
pub fn sub(
self,
rhs: &'b Quaternion<T>
) -> <&'a Quaternion<T> as Sub<&'b Quaternion<T>>>::Output
[src]Performs the -
operation. Read more
impl<'b, T> Sub<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'b, T> Sub<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
impl<T> Sub<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Sub<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
impl<'a, T> Sub<Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'a, T> Sub<Quaternion<T>> for &'a Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]type Output = Quaternion<T>
type Output = Quaternion<T>
The resulting type after applying the -
operator.
Performs the -
operation. Read more
impl<'b, T> SubAssign<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<'b, T> SubAssign<&'b Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the -=
operation. Read more
impl<T> SubAssign<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> SubAssign<Quaternion<T>> for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]Performs the -=
operation. Read more
impl<T1, T2> SubsetOf<Quaternion<T2>> for Quaternion<T1> where
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
[src]
impl<T1, T2> SubsetOf<Quaternion<T2>> for Quaternion<T1> where
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
[src]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.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
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
pub fn ulps_eq(
&self,
other: &Quaternion<T>,
epsilon: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon,
max_ulps: u32
) -> bool
[src]
pub fn ulps_eq(
&self,
other: &Quaternion<T>,
epsilon: <Quaternion<T> as AbsDiffEq<Quaternion<T>>>::Epsilon,
max_ulps: u32
) -> bool
[src]A test for equality that uses units in the last place (ULP) if the values are far apart.
impl<T> Zero for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]
impl<T> Zero for Quaternion<T> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
[src]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
impl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<T> DynHash for T where
T: DynEq + Hash,
impl<T> DynHash for T where
T: DynEq + Hash,
impl<T> FromWorld for T where
T: Default,
impl<T> FromWorld for T where
T: Default,
pub fn from_world(_world: &mut World) -> T
pub fn from_world(_world: &mut World) -> T
Creates Self
using data from the given [World]
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
type Output = T
type Output = T
Should always be Self
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
pub fn is_in_subset(&self) -> bool
pub fn is_in_subset(&self) -> bool
Checks if self
is actually part of its subset T
(and can be converted to it).
pub fn to_subset_unchecked(&self) -> SS
pub fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
pub fn from_subset(element: &SS) -> SP
pub fn from_subset(element: &SS) -> SP
The inclusion map: converts self
to the equivalent element of its superset.
pub fn clone_type_data(&self) -> Box<dyn TypeData + 'static, Global>
pub fn vzip(self) -> V
impl<T> ClosedNeg for T where
T: Neg<Output = T>,