Struct num_quaternion::UnitQuaternion

pub struct UnitQuaternion<T>(/* private fields */);

A quaternion with norm $1$.

Unit quaternions form a non-commutative group that can be conveniently used for rotating 3D vectors. A 3D vector can be interpreted as a pure quaternion (a quaternion with a real part of zero). Such a pure quaternion $v$ can be rotated in 3D space by computing $q^{-1} \cdot v \cdot q$ for a unit quaternion $q$. The resulting product is again a pure quaternion, which is $v$ rotated around the axis given by the imaginary part of $q$. The method rotate_vector performs this operation efficiently. The angle of rotation is double the angle between $1$ and $q$ interpreted as 4D vectors.

You can create a UnitQuaternion by normalizing a Quaternion using the Quaternion::normalize method. Alternatively, you can use from_euler_angles or from_rotation_vector to obtain one. The inverse functions to_euler_angles and to_rotation_vector are also provided.

UnitQuaternion offers the same arithmetic operations as Quaternion. Multiplying two unit quaternions yields a unit quaternion in theory. However, due to limited machine precision, rounding errors accumulate in practice and the resulting norm may deviate from $1$ over time. Thus, when you multiply unit quaternions many times, you may need to adjust the norm to maintain accuracy. This can be done by calling the function adjust_norm.

Furthermore, you can interpolate uniformly between two quaternions using the slerp method, which stands for spherical linear interpolation. This can be used for smooth transitions between 3D rotations.

See also Quaternion.

Examples

Basic usage:

// Creating a UnitQuaternion from Euler angles
let (roll, pitch, yaw) = (1.5, 1.0, 3.0);
let uq = UnitQuaternion::from_euler_angles(roll, pitch, yaw);

// Rotating a vector using the UnitQuaternion
let vector = [1.0, 0.0, 0.0];
let rotated_vector = uq.rotate_vector(vector);

Implementations

impl<T> UnitQuaternion<T>

where T: Float,

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

Creates a new Quaternion from roll, pitch and yaw angles.

pub fn from_euler_angles_struct(angles: EulerAngles<T>) -> Self

Creates a new Quaternion from Euler angles.

Note. The reason that this function is marked as unstable is that I’m not 100% confident about the naming of the function.

impl<T> UnitQuaternion<T>

where T: Float + FloatConst,

pub fn to_euler_angles(&self) -> EulerAngles<T>

Converts the UnitQuaternion to roll, pitch, and yaw angles.

impl<T> UnitQuaternion<T>

where T: Float,

pub fn from_rotation_vector(v: &[T; 3]) -> Self

Returns a quaternion from a vector which is parallel to the rotation axis and whose norm is the rotation angle.

This function is the inverse of to_rotation_vector.

impl<T> UnitQuaternion<T>

where T: Float + FloatConst,

pub fn to_rotation_vector(&self) -> [T; 3]

Returns a rotation vector which is parallel to the rotation axis and whose norm is the rotation angle.

This function is the inverse of from_rotation_vector.

impl<T> UnitQuaternion<T>

where T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + One + Clone,

pub fn to_rotation_matrix3x3(self) -> [T; 9]

Computes the rotation matrix implied by a unit quaternion.

The matrix is returned in row major order, i. e. the indices into the result array yield the elements in the following order:

    [0, 1, 2,
     3, 4, 5,
     6, 7, 8]

Multiplying by the returned matrix gives the same result as using rotate_vector modulo slightly different rounding errors.

Runtime Considerations

The matrix multiplication itself can be assumed to be more runtime efficient than rotate_vector. However, computing the matrix also comes with additional cost. Thus general advice is: Use rotate_vector, if you want to rotate a single vector. Perform the matrix multiplication, if more than one vector needs to be rotated.

impl<T> UnitQuaternion<T>

where T: Float,

pub fn from_rotation_matrix3x3(mat: &impl ReadMat3x3<T>) -> UnitQuaternion<T>

Computes a quaternion from a 3x3 rotation matrix.

The input matrix $O$ is required to be an actual rotation matrix, i. e. $O^TO$ is the identity matrix and $\det O = 1$ (neglecting floating point rounding errors).

The quaternion solution with non-negative real part is returned. This function reverses the method to_rotation_matrix3x3.

impl<T> UnitQuaternion<T>

where T: Float,

pub fn from_two_vectors(a: &[T; 3], b: &[T; 3]) -> UnitQuaternion<T>

Returns a unit quaternion that rotates vector $\vec a$ to vector $\vec b$ with the minimum angle of rotation.

The method rotate_vector can be used to apply the rotation. The resulting unit quaternion maps the ray ${t\vec{a} : t > 0}$ to the ray ${t\vec{b} : t > 0}$.

Note that the input vectors neither need to be normalized nor have the same magnitude. In the case where the input vectors point in opposite directions, there are multiple solutions to the problem, and one will be returned. If one (or both) of the input vectors is the zero vector, the unit quaternion $1$ is returned.

impl<T> UnitQuaternion<T>

where T: ConstZero + ConstOne,

pub const ONE: Self = _

A constant UnitQuaternion of value $1$.

See also UnitQuaternion::one, Quaternion::ONE.

pub const I: Self = _

A constant UnitQuaternion of value $i$.

See also UnitQuaternion::i, Quaternion::I.

pub const J: Self = _

A constant UnitQuaternion of value $j$.

See also UnitQuaternion::j, Quaternion::J.

pub const K: Self = _

A constant UnitQuaternion of value $k$.

See also UnitQuaternion::k, Quaternion::K.

impl<T> UnitQuaternion<T>

where T: Zero + One,

pub fn i() -> Self

Returns the imaginary unit $i$.

See also UnitQuaternion::I, Quaternion::i.

pub fn j() -> Self

Returns the imaginary unit $j$.

See also UnitQuaternion::J, Quaternion::j.

pub fn k() -> Self

Returns the imaginary unit $k$.

See also UnitQuaternion::K, Quaternion::k.

impl<T> UnitQuaternion<T>

pub fn into_quaternion(self) -> Quaternion<T>

Returns the inner quaternion.

pub fn as_quaternion(&self) -> &Quaternion<T>

Returns a reference to the inner quaternion.

impl<T> UnitQuaternion<T>

where T: Clone + Neg<Output = T>,

pub fn conj(&self) -> Self

Returns the conjugate quaternion. i.e. the imaginary part is negated.

impl<T> UnitQuaternion<T>

where T: Clone + Neg<Output = T>,

pub fn inv(&self) -> Self

Returns the multiplicative inverse 1/self.

This is the same as the conjugate of self.

impl<T> UnitQuaternion<T>

where T: Add<T, Output = T> + Mul<T, Output = T>,

pub fn dot(self, other: Self) -> T

Computes the dot product of two unit quaternions interpreted as 4D real vectors.

impl<T> UnitQuaternion<T>

where T: Float,

pub fn adjust_norm(self) -> Self

Renormalizes self.

By many multiplications of unit quaternions, round off errors can lead to norms which are deviating from $1$ significantly. This function fixes that inaccuracy.

impl<T> UnitQuaternion<T>

where T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Clone,

pub fn rotate_vector(self, vector: [T; 3]) -> [T; 3]

Rotates a vector using a quaternion.

Given a unit quaternion $q$ and a pure quaternion $v$ (i. e. a quaternion with real part zero), the mapping $v \mapsto q^*vq$ is a 3D rotation in the space of pure quaternions. This function performs this 3D rotation efficiently.

impl<T> UnitQuaternion<T>

where T: Float,

pub fn slerp(&self, other: &Self, t: T) -> Self

Spherical linear interpolation between two unit quaternions.

t should be in the range [0, 1], where 0 returns self and 1 returns other or -other, whichever is closer to self.

impl<T> UnitQuaternion<T>

where T: Float + FloatConst,

pub fn sqrt(self) -> Self

Computes the square root of a unit quaternion.

Given an input unit quaternion $c$, this function returns the unit quaternion $q$ which satisfies $q^2 = c$ and has a real part with a positive sign.

For $c = -1$, there are multiple solutions to these constraints. In that case $q = \pm i$ is returned. The sign is determined by the input coefficient of the imaginary unit $i$.

In any case, the three imaginary parts of the result have the same sign as the three imaginary parts of the input.

Trait Implementations

impl<T> Add<&Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Add<Quaternion<T>> + Clone, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Add<Quaternion<T>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Quaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<&Quaternion<T>> for UnitQuaternion<T>

where Self: Add<Quaternion<T>>, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Add<Quaternion<T>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Quaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<&T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Add<T> + Clone, T: Clone,

type Output = <UnitQuaternion<T> as Add<T>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Performs the + operation.

impl<T> Add<&T> for UnitQuaternion<T>

where Self: Add<T>, T: Clone,

type Output = <UnitQuaternion<T> as Add<T>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self::Output

Performs the + operation.

impl<T> Add<&UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Add<UnitQuaternion<T>> + Clone, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Add<UnitQuaternion<T>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<&UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Add<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<&UnitQuaternion<T>> for Quaternion<T>

where Self: Add<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Add<UnitQuaternion<T>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<&UnitQuaternion<T>> for UnitQuaternion<T>

where Self: Add<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Add<Quaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Add<Quaternion<T>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Quaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<Quaternion<T>> for UnitQuaternion<T>

where Quaternion<T>: Add<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the + operator.

fn add(self, rhs: Quaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Add<T> + Clone,

type Output = <UnitQuaternion<T> as Add<T>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add<T> for UnitQuaternion<T>

where Quaternion<T>: Add<T, Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add<UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Add<UnitQuaternion<T>> + Clone,

type Output = <Quaternion<T> as Add<UnitQuaternion<T>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Add<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Add<UnitQuaternion<T>> for Quaternion<T>

where T: Add<T, Output = T>,

type Output = Quaternion<T>

The resulting type after applying the + operator.

fn add(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl Add<UnitQuaternion<f32>> for f32

type Output = Quaternion<f32>

The resulting type after applying the + operator.

fn add(self, rhs: UQ32) -> Self::Output

Performs the + operation.

impl Add<UnitQuaternion<f64>> for f64

type Output = Quaternion<f64>

The resulting type after applying the + operator.

fn add(self, rhs: UQ64) -> Self::Output

Performs the + operation.

impl<T> Add for UnitQuaternion<T>

where Quaternion<T>: Add<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the + operator.

fn add(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the + operation.

impl<T> Borrow<Quaternion<T>> for UnitQuaternion<T>

fn borrow(&self) -> &Quaternion<T>

Immutably borrows from an owned value.

impl<T: Clone> Clone for UnitQuaternion<T>

fn clone(&self) -> UnitQuaternion<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> ConstOne for UnitQuaternion<T>

where T: ConstZero + ConstOne + Num + Clone,

const ONE: Self = Self::ONE

The multiplicative identity element of Self, 1.

impl<T: Debug> Debug for UnitQuaternion<T>

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

Formats the value using the given formatter.

impl<T> Default for UnitQuaternion<T>

where T: Num + Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for UnitQuaternion<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div<&Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Div<Quaternion<T>> + Clone, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Div<Quaternion<T>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Quaternion<T>) -> Self::Output

Performs the / operation.

impl<T> Div<&Quaternion<T>> for UnitQuaternion<T>

where Self: Div<Quaternion<T>>, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Div<Quaternion<T>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Quaternion<T>) -> Self::Output

Performs the / operation.

impl<T> Div<&T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Div<T> + Clone, T: Clone,

type Output = <UnitQuaternion<T> as Div<T>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &T) -> Self::Output

Performs the / operation.

impl<T> Div<&T> for UnitQuaternion<T>

where Self: Div<T>, T: Clone,

type Output = <UnitQuaternion<T> as Div<T>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &T) -> Self::Output

Performs the / operation.

impl<T> Div<&UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Div<UnitQuaternion<T>> + Clone, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Div<UnitQuaternion<T>>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<&UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Div<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Div>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<&UnitQuaternion<T>> for Quaternion<T>

where Self: Div<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Div<UnitQuaternion<T>>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<&UnitQuaternion<T>> for UnitQuaternion<T>

where Self: Div<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Div>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Div<Quaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Div<Quaternion<T>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Quaternion<T>) -> Self::Output

Performs the / operation.

impl<T> Div<Quaternion<T>> for UnitQuaternion<T>

where Quaternion<T>: Div<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the / operator.

fn div(self, rhs: Quaternion<T>) -> Self::Output

Performs the / operation.

impl<T> Div<T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Div<T> + Clone,

type Output = <UnitQuaternion<T> as Div<T>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Div<T> for UnitQuaternion<T>

where Quaternion<T>: Div<T, Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Div<UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Div<UnitQuaternion<T>> + Clone,

type Output = <Quaternion<T> as Div<UnitQuaternion<T>>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Div<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Div>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<UnitQuaternion<T>> for Quaternion<T>

where Quaternion<T>: Mul<Output = Quaternion<T>>, T: Neg<Output = T> + Clone,

type Output = Quaternion<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<UnitQuaternion<f32>> for f32

type Output = Quaternion<f32>

The resulting type after applying the / operator.

fn div(self, rhs: UQ32) -> Self::Output

Performs the / operation.

impl Div<UnitQuaternion<f64>> for f64

type Output = Quaternion<f64>

The resulting type after applying the / operator.

fn div(self, rhs: UQ64) -> Self::Output

Performs the / operation.

impl<T> Div for UnitQuaternion<T>

where Quaternion<T>: Mul<Output = Quaternion<T>>, T: Clone + Neg<Output = T>,

type Output = UnitQuaternion<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T> From<&'a UnitQuaternion<T>> for &'a Quaternion<T>

fn from(q: &'a UnitQuaternion<T>) -> Self

Converts to this type from the input type.

impl<T> From<UnitQuaternion<T>> for Quaternion<T>

fn from(q: UnitQuaternion<T>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for UnitQuaternion<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Inv for &UnitQuaternion<T>

where T: Clone + Neg<Output = T>,

type Output = UnitQuaternion<T>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T> Inv for UnitQuaternion<T>

where T: Clone + Neg<Output = T>,

type Output = UnitQuaternion<T>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T> Mul<&Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Mul<Quaternion<T>> + Clone, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Mul<Quaternion<T>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Quaternion<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<&Quaternion<T>> for UnitQuaternion<T>

where Self: Mul<Quaternion<T>>, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Mul<Quaternion<T>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Quaternion<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<&T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Mul<T> + Clone, T: Clone,

type Output = <UnitQuaternion<T> as Mul<T>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<T> Mul<&T> for UnitQuaternion<T>

where Self: Mul<T>, T: Clone,

type Output = <UnitQuaternion<T> as Mul<T>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<T> Mul<&UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Mul<UnitQuaternion<T>> + Clone, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Mul<UnitQuaternion<T>>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Mul<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Mul>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&UnitQuaternion<T>> for Quaternion<T>

where Self: Mul<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Mul<UnitQuaternion<T>>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&UnitQuaternion<T>> for UnitQuaternion<T>

where Self: Mul<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Mul>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Mul<Quaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Mul<Quaternion<T>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Quaternion<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<Quaternion<T>> for UnitQuaternion<T>

where Quaternion<T>: Mul<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Quaternion<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Mul<T> + Clone,

type Output = <UnitQuaternion<T> as Mul<T>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for UnitQuaternion<T>

where Quaternion<T>: Mul<T, Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul<UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Mul<UnitQuaternion<T>> + Clone,

type Output = <Quaternion<T> as Mul<UnitQuaternion<T>>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Mul<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Mul>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<UnitQuaternion<T>> for Quaternion<T>

where Quaternion<T>: Mul<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UnitQuaternion<f32>> for f32

type Output = Quaternion<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: UQ32) -> Self::Output

Performs the * operation.

impl Mul<UnitQuaternion<f64>> for f64

type Output = Quaternion<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: UQ64) -> Self::Output

Performs the * operation.

impl<T> Mul for UnitQuaternion<T>

where Quaternion<T>: Mul<Output = Quaternion<T>>,

type Output = UnitQuaternion<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Neg for UnitQuaternion<T>

where T: Neg<Output = T>,

type Output = UnitQuaternion<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> One for UnitQuaternion<T>

where T: Num + Clone,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<T: PartialEq> PartialEq for UnitQuaternion<T>

fn eq(&self, other: &UnitQuaternion<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for UnitQuaternion<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub<&Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Sub<Quaternion<T>> + Clone, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Sub<Quaternion<T>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Quaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<&Quaternion<T>> for UnitQuaternion<T>

where Self: Sub<Quaternion<T>>, Quaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Sub<Quaternion<T>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Quaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<&T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Sub<T> + Clone, T: Clone,

type Output = <UnitQuaternion<T> as Sub<T>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<T> Sub<&T> for UnitQuaternion<T>

where Self: Sub<T>, T: Clone,

type Output = <UnitQuaternion<T> as Sub<T>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation.

impl<T> Sub<&UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Sub<UnitQuaternion<T>> + Clone, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Sub<UnitQuaternion<T>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<&UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Sub<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<&UnitQuaternion<T>> for Quaternion<T>

where Self: Sub<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <Quaternion<T> as Sub<UnitQuaternion<T>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<&UnitQuaternion<T>> for UnitQuaternion<T>

where Self: Sub<UnitQuaternion<T>>, UnitQuaternion<T>: Clone,

type Output = <UnitQuaternion<T> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<Quaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Sub<Quaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Sub<Quaternion<T>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Quaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<Quaternion<T>> for UnitQuaternion<T>

where Quaternion<T>: Sub<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Quaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for &UnitQuaternion<T>

where UnitQuaternion<T>: Sub<T> + Clone,

type Output = <UnitQuaternion<T> as Sub<T>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for UnitQuaternion<T>

where Quaternion<T>: Sub<T, Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub<UnitQuaternion<T>> for &Quaternion<T>

where Quaternion<T>: Sub<UnitQuaternion<T>> + Clone,

type Output = <Quaternion<T> as Sub<UnitQuaternion<T>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<UnitQuaternion<T>> for &UnitQuaternion<T>

where UnitQuaternion<T>: Sub<UnitQuaternion<T>> + Clone,

type Output = <UnitQuaternion<T> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<UnitQuaternion<T>> for Quaternion<T>

where T: Sub<T, Output = T>,

type Output = Quaternion<T>

The resulting type after applying the - operator.

fn sub(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl Sub<UnitQuaternion<f32>> for f32

type Output = Quaternion<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: UQ32) -> Self::Output

Performs the - operation.

impl Sub<UnitQuaternion<f64>> for f64

type Output = Quaternion<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: UQ64) -> Self::Output

Performs the - operation.

impl<T> Sub for UnitQuaternion<T>

where Quaternion<T>: Sub<Output = Quaternion<T>>,

type Output = Quaternion<T>

The resulting type after applying the - operator.

fn sub(self, rhs: UnitQuaternion<T>) -> Self::Output

Performs the - operation.

impl<T: Copy> Copy for UnitQuaternion<T>

impl<T: Eq> Eq for UnitQuaternion<T>

impl<T> StructuralPartialEq for UnitQuaternion<T>