[−][src]Struct nalgebra::geometry::Quaternion
A quaternion. See the type alias UnitQuaternion = Unit<Quaternion>
for a quaternion
that may be used as a rotation.
Fields
coords: Vector4<N>
This quaternion as a 4D vector of coordinates in the [ x, y, z, w ]
storage order.
Methods
impl<N: Real> Quaternion<N>
[src]
pub fn into_owned(self) -> Quaternion<N>
[src]
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) -> Quaternion<N>
[src]
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 normalize(&self) -> Quaternion<N>
[src]
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);
pub fn conjugate(&self) -> Quaternion<N>
[src]
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);
pub fn try_inverse(&self) -> Option<Quaternion<N>>
[src]
Inverts this quaternion if it is not zero.
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());
pub fn lerp(&self, other: &Quaternion<N>, t: N) -> Quaternion<N>
[src]
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
) -> MatrixSlice<N, U3, U1, RStride<N, U4, U1>, CStride<N, U4, U1>>
[src]
&self
) -> MatrixSlice<N, U3, U1, RStride<N, U4, U1>, CStride<N, U4, U1>>
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);
pub fn scalar(&self) -> N
[src]
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);
pub fn as_vector(&self) -> &Vector4<N>
[src]
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 ::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));
pub fn norm(&self) -> N
[src]
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);
pub fn magnitude(&self) -> N
[src]
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);
pub fn norm_squared(&self) -> N
[src]
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);
pub fn magnitude_squared(&self) -> N
[src]
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);
pub fn dot(&self, rhs: &Self) -> N
[src]
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);
pub fn polar_decomposition(&self) -> (N, N, Option<Unit<Vector3<N>>>)
[src]
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()));
pub fn ln(&self) -> Quaternion<N>
[src]
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)
pub fn exp(&self) -> Quaternion<N>
[src]
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)
pub fn exp_eps(&self, eps: N) -> Quaternion<N>
[src]
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());
pub fn powf(&self, n: N) -> Quaternion<N>
[src]
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 Vector4<N>
[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
) -> MatrixSliceMut<N, U3, U1, RStride<N, U4, U1>, CStride<N, U4, U1>>
[src]
&mut self
) -> MatrixSliceMut<N, U3, U1, RStride<N, U4, U1>, CStride<N, U4, U1>>
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);
pub fn conjugate_mut(&mut self)
[src]
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);
pub fn try_inverse_mut(&mut self) -> bool
[src]
Inverts this quaternion in-place if it is not zero.
Example
let mut q = Quaternion::new(1.0, 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.0, 0.0, 0.0, 0.0); assert!(!q.try_inverse_mut());
pub fn normalize_mut(&mut self) -> N
[src]
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);
impl<N: Real> Quaternion<N>
[src]
pub fn from_vector(vector: Vector4<N>) -> Self
[src]
Use ::from
instead.
Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the w
vector component.
pub fn new(w: N, i: N, j: N, k: N) -> Self
[src]
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_parts<SB>(scalar: N, vector: Vector<N, U3, SB>) -> Self where
SB: Storage<N, U3>,
[src]
SB: Storage<N, U3>,
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));
pub fn from_polar_decomposition<SB>(
scale: N,
theta: N,
axis: Unit<Vector<N, U3, SB>>
) -> Self where
SB: Storage<N, U3>,
[src]
scale: N,
theta: N,
axis: Unit<Vector<N, U3, SB>>
) -> Self where
SB: Storage<N, U3>,
Creates a new quaternion from its polar decomposition.
Note that axis
is assumed to be a unit vector.
pub fn identity() -> Self
[src]
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);
Trait Implementations
impl<N: Real + Eq> Eq for Quaternion<N>
[src]
impl<N: Real> Clone for Quaternion<N>
[src]
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<N: Real> PartialEq<Quaternion<N>> for Quaternion<N>
[src]
impl<N: Real> From<Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>> for Quaternion<N>
[src]
impl<N: Real> Copy for Quaternion<N>
[src]
impl<N: Real> DerefMut for Quaternion<N>
[src]
impl<N: Real + Hash> Hash for Quaternion<N>
[src]
fn hash<H: Hasher>(&self, state: &mut H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<N: Debug + Real> Debug for Quaternion<N>
[src]
impl<N: Real + Display> Display for Quaternion<N>
[src]
impl<'a, 'b, N: Real> Sub<&'b Quaternion<N>> for &'a Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Quaternion<N>) -> Self::Output
[src]
impl<'a, N: Real> Sub<Quaternion<N>> for &'a Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the -
operator.
fn sub(self, rhs: Quaternion<N>) -> Self::Output
[src]
impl<'b, N: Real> Sub<&'b Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Quaternion<N>) -> Self::Output
[src]
impl<N: Real> Sub<Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the -
operator.
fn sub(self, rhs: Quaternion<N>) -> Self::Output
[src]
impl<N: Real> Div<N> for Quaternion<N>
[src]
type Output = Quaternion<N>
The resulting type after applying the /
operator.
fn div(self, n: N) -> Self::Output
[src]
impl<'a, N: Real> Div<N> for &'a Quaternion<N>
[src]
type Output = Quaternion<N>
The resulting type after applying the /
operator.
fn div(self, n: N) -> Self::Output
[src]
impl<'a, 'b, N: Real> Add<&'b Quaternion<N>> for &'a Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Quaternion<N>) -> Self::Output
[src]
impl<'a, N: Real> Add<Quaternion<N>> for &'a Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the +
operator.
fn add(self, rhs: Quaternion<N>) -> Self::Output
[src]
impl<'b, N: Real> Add<&'b Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Quaternion<N>) -> Self::Output
[src]
impl<N: Real> Add<Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the +
operator.
fn add(self, rhs: Quaternion<N>) -> Self::Output
[src]
impl<'a, 'b, N: Real> Mul<&'b Quaternion<N>> for &'a Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Quaternion<N>) -> Self::Output
[src]
impl<'a, N: Real> Mul<Quaternion<N>> for &'a Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quaternion<N>) -> Self::Output
[src]
impl<'b, N: Real> Mul<&'b Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Quaternion<N>) -> Self::Output
[src]
impl<N: Real> Mul<Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Quaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quaternion<N>) -> Self::Output
[src]
impl<N: Real> Mul<N> for Quaternion<N>
[src]
type Output = Quaternion<N>
The resulting type after applying the *
operator.
fn mul(self, n: N) -> Self::Output
[src]
impl<'a, N: Real> Mul<N> for &'a Quaternion<N>
[src]
type Output = Quaternion<N>
The resulting type after applying the *
operator.
fn mul(self, n: N) -> Self::Output
[src]
impl Mul<Quaternion<f32>> for f32
[src]
type Output = Quaternion<f32>
The resulting type after applying the *
operator.
fn mul(self, right: Quaternion<f32>) -> Self::Output
[src]
impl<'b> Mul<&'b Quaternion<f32>> for f32
[src]
type Output = Quaternion<f32>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Quaternion<f32>) -> Self::Output
[src]
impl Mul<Quaternion<f64>> for f64
[src]
type Output = Quaternion<f64>
The resulting type after applying the *
operator.
fn mul(self, right: Quaternion<f64>) -> Self::Output
[src]
impl<'b> Mul<&'b Quaternion<f64>> for f64
[src]
type Output = Quaternion<f64>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Quaternion<f64>) -> Self::Output
[src]
impl<N: Real> Neg for Quaternion<N>
[src]
type Output = Quaternion<N>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl<'a, N: Real> Neg for &'a Quaternion<N>
[src]
type Output = Quaternion<N>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl<'b, N: Real> AddAssign<&'b Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
fn add_assign(&mut self, rhs: &'b Quaternion<N>)
[src]
impl<N: Real> AddAssign<Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
fn add_assign(&mut self, rhs: Quaternion<N>)
[src]
impl<'b, N: Real> SubAssign<&'b Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
fn sub_assign(&mut self, rhs: &'b Quaternion<N>)
[src]
impl<N: Real> SubAssign<Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
fn sub_assign(&mut self, rhs: Quaternion<N>)
[src]
impl<N: Real> MulAssign<N> for Quaternion<N>
[src]
fn mul_assign(&mut self, n: N)
[src]
impl<'b, N: Real> MulAssign<&'b Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
fn mul_assign(&mut self, rhs: &'b Quaternion<N>)
[src]
impl<N: Real> MulAssign<Quaternion<N>> for Quaternion<N> where
DefaultAllocator: Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1>,
fn mul_assign(&mut self, rhs: Quaternion<N>)
[src]
impl<N: Real> DivAssign<N> for Quaternion<N>
[src]
fn div_assign(&mut self, n: N)
[src]
impl<N: Real> Deref for Quaternion<N>
[src]
impl<N: Real> Index<usize> for Quaternion<N>
[src]
impl<N: Real> IndexMut<usize> for Quaternion<N>
[src]
impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq<Quaternion<N>> for Quaternion<N>
[src]
type Epsilon = N
Used for specifying relative comparisons.
fn default_epsilon() -> Self::Epsilon
[src]
fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
[src]
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
[src]
impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq<Quaternion<N>> for Quaternion<N>
[src]
fn default_max_relative() -> Self::Epsilon
[src]
fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
impl<N: Real + UlpsEq<Epsilon = N>> UlpsEq<Quaternion<N>> for Quaternion<N>
[src]
fn default_max_ulps() -> u32
[src]
fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
impl<N: Real> Zero for Quaternion<N>
[src]
impl<N: Real> One for Quaternion<N>
[src]
fn one() -> Self
[src]
fn set_one(&mut self)
[src]
fn is_one(&self) -> bool where
Self: PartialEq<Self>,
[src]
Self: PartialEq<Self>,
impl<N: Real> Distribution<Quaternion<N>> for Standard where
Standard: Distribution<N>,
[src]
Standard: Distribution<N>,
fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Quaternion<N>
[src]
fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
R: Rng,
[src]
R: Rng,
impl<N: Real> AbstractMagma<Multiplicative> for Quaternion<N>
[src]
impl<N: Real> AbstractMagma<Additive> for Quaternion<N>
[src]
impl<N: Real> AbstractQuasigroup<Additive> for Quaternion<N>
[src]
fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where
Self: RelativeEq<Self>,
[src]
Self: RelativeEq<Self>,
fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where
Self: Eq,
[src]
Self: Eq,
impl<N: Real> AbstractSemigroup<Multiplicative> for Quaternion<N>
[src]
fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
Self: RelativeEq<Self>,
[src]
Self: RelativeEq<Self>,
fn prop_is_associative(args: (Self, Self, Self)) -> bool where
Self: Eq,
[src]
Self: Eq,
impl<N: Real> AbstractSemigroup<Additive> for Quaternion<N>
[src]
fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
Self: RelativeEq<Self>,
[src]
Self: RelativeEq<Self>,
fn prop_is_associative(args: (Self, Self, Self)) -> bool where
Self: Eq,
[src]
Self: Eq,
impl<N: Real> AbstractLoop<Additive> for Quaternion<N>
[src]
impl<N: Real> AbstractMonoid<Multiplicative> for Quaternion<N>
[src]
fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where
Self: RelativeEq<Self>,
[src]
Self: RelativeEq<Self>,
fn prop_operating_identity_element_is_noop(args: (Self,)) -> bool where
Self: Eq,
[src]
Self: Eq,
impl<N: Real> AbstractMonoid<Additive> for Quaternion<N>
[src]
fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where
Self: RelativeEq<Self>,
[src]
Self: RelativeEq<Self>,
fn prop_operating_identity_element_is_noop(args: (Self,)) -> bool where
Self: Eq,
[src]
Self: Eq,
impl<N: Real> AbstractGroup<Additive> for Quaternion<N>
[src]
impl<N: Real> AbstractGroupAbelian<Additive> for Quaternion<N>
[src]
fn prop_is_commutative_approx(args: (Self, Self)) -> bool where
Self: RelativeEq<Self>,
[src]
Self: RelativeEq<Self>,
fn prop_is_commutative(args: (Self, Self)) -> bool where
Self: Eq,
[src]
Self: Eq,
impl<N: Real> Identity<Multiplicative> for Quaternion<N>
[src]
impl<N: Real> Identity<Additive> for Quaternion<N>
[src]
impl<N: Real> Inverse<Additive> for Quaternion<N>
[src]
fn inverse(&self) -> Self
[src]
fn inverse_mut(&mut self)
[src]
impl<N: Real> AbstractModule<Additive, Additive, Multiplicative> for Quaternion<N>
[src]
impl<N1, N2> SubsetOf<Quaternion<N2>> for Quaternion<N1> where
N1: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> Quaternion<N2>
[src]
fn is_in_subset(q: &Quaternion<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(q: &Quaternion<N2>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N: Real> Module for Quaternion<N>
[src]
type Ring = N
The underlying scalar field.
impl<N: Real> VectorSpace for Quaternion<N>
[src]
type Field = N
The underlying scalar field.
impl<N: Real> NormedSpace for Quaternion<N>
[src]
fn norm_squared(&self) -> N
[src]
fn norm(&self) -> N
[src]
fn normalize(&self) -> Self
[src]
fn normalize_mut(&mut self) -> N
[src]
fn try_normalize(&self, min_norm: N) -> Option<Self>
[src]
fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
[src]
impl<N: Real> FiniteDimVectorSpace for Quaternion<N>
[src]
fn dimension() -> usize
[src]
fn canonical_basis_element(i: usize) -> Self
[src]
fn dot(&self, other: &Self) -> N
[src]
unsafe fn component_unchecked(&self, i: usize) -> &N
[src]
unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N
[src]
fn canonical_basis<F>(f: F) where
F: FnMut(&Self) -> bool,
[src]
F: FnMut(&Self) -> bool,
Auto Trait Implementations
impl<N> Send for Quaternion<N> where
N: Scalar,
N: Scalar,
impl<N> Unpin for Quaternion<N> where
N: Scalar + Unpin,
N: Scalar + Unpin,
impl<N> Sync for Quaternion<N> where
N: Scalar,
N: Scalar,
impl<N> RefUnwindSafe for Quaternion<N> where
N: RefUnwindSafe + Scalar,
N: RefUnwindSafe + Scalar,
impl<N> UnwindSafe for Quaternion<N> where
N: Scalar + UnwindSafe,
N: Scalar + UnwindSafe,
Blanket Implementations
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self
impl<T> Rand for T where
Standard: Distribution<T>,
[src]
Standard: Distribution<T>,
impl<T> ClosedNeg for T where
T: Neg<Output = T>,
[src]
T: Neg<Output = T>,
impl<T, Right> ClosedAdd<Right> for T where
T: Add<Right, Output = T> + AddAssign<Right>,
[src]
T: Add<Right, Output = T> + AddAssign<Right>,
impl<T, Right> ClosedSub<Right> for T where
T: Sub<Right, Output = T> + SubAssign<Right>,
[src]
T: Sub<Right, Output = T> + SubAssign<Right>,
impl<T, Right> ClosedMul<Right> for T where
T: Mul<Right, Output = T> + MulAssign<Right>,
[src]
T: Mul<Right, Output = T> + MulAssign<Right>,
impl<T, Right> ClosedDiv<Right> for T where
T: Div<Right, Output = T> + DivAssign<Right>,
[src]
T: Div<Right, Output = T> + DivAssign<Right>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
[src]
fn is_in_subset(&self) -> bool
[src]
unsafe fn to_subset_unchecked(&self) -> SS
[src]
fn from_subset(element: &SS) -> SP
[src]
impl<T> AdditiveMagma for T where
T: AbstractMagma<Additive>,
[src]
T: AbstractMagma<Additive>,
impl<T> AdditiveQuasigroup for T where
T: AbstractQuasigroup<Additive> + ClosedSub<T> + AdditiveMagma,
[src]
T: AbstractQuasigroup<Additive> + ClosedSub<T> + AdditiveMagma,
impl<T> AdditiveLoop for T where
T: AbstractLoop<Additive> + ClosedNeg + AdditiveQuasigroup + Zero,
[src]
T: AbstractLoop<Additive> + ClosedNeg + AdditiveQuasigroup + Zero,
impl<T> AdditiveSemigroup for T where
T: AbstractSemigroup<Additive> + ClosedAdd<T> + AdditiveMagma,
[src]
T: AbstractSemigroup<Additive> + ClosedAdd<T> + AdditiveMagma,
impl<T> AdditiveMonoid for T where
T: AbstractMonoid<Additive> + AdditiveSemigroup + Zero,
[src]
T: AbstractMonoid<Additive> + AdditiveSemigroup + Zero,
impl<T> AdditiveGroup for T where
T: AbstractGroup<Additive> + AdditiveLoop + AdditiveMonoid,
[src]
T: AbstractGroup<Additive> + AdditiveLoop + AdditiveMonoid,
impl<T> AdditiveGroupAbelian for T where
T: AbstractGroupAbelian<Additive> + AdditiveGroup,
[src]
T: AbstractGroupAbelian<Additive> + AdditiveGroup,
impl<T> MultiplicativeMagma for T where
T: AbstractMagma<Multiplicative>,
[src]
T: AbstractMagma<Multiplicative>,
impl<T> MultiplicativeSemigroup for T where
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
[src]
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
impl<T> MultiplicativeMonoid for T where
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
[src]
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,