Struct Quaternion

pub struct Quaternion(/* private fields */);

Quaternions are a number system that extends the complex numbers which can be used for efficiently computing spatial rotations.

They’re computed as the quotient of two directed lines in a three-dimensional space, or equivalently as the quotient of two vectors.

For given real numbers a, b, c, and d, they take the form:

a + bi + cj + dk

where i, j, and k are the fundamental quaternion units:

i² = j² = k² = i*j*k = -1

Quaternion multiplication is non-commutative:

x	1	i	j	k
1	1	i	j	k
i	i	-1	k	-j
j	j	-k	-1	i
k	k	j	-i	-1

Implementations

impl Quaternion

pub const IDENTITY: Self

Identity quaternion.

pub const fn new(a: f32, b: f32, c: f32, d: f32) -> Self

Create a new quaternion.

pub fn from_two_vectors<C>(u: Vector3d<C>, v: Vector3d<C>) -> Self

where C: Component + Into<f32>,

Get the quaternion that represents the smallest rotation between two vectors.

pub fn conj(self) -> Self

Returns the conjugate of this quaternion.

pub fn dot(self, rhs: Self) -> f32

Returns the dot product of this quaternion.

pub fn inv(self) -> Self

Compute the inverse of this quaternion.

Panics if Quaternion::norm is zero.

pub fn magnitude(self) -> f32

Compute the magnitude (a.k.a length) of this quaternion.

pub fn norm(self) -> f32

Returns the norm of this quaternion, i.e. a²+b²+c²+d².

https://www.mathworks.com/help/aeroblks/quaternionnorm.html

pub fn axis_angle<C>(v: Vector3d<C>, theta: C) -> Self

where C: Component + Into<f32>,

Available on crate feature vector only.

Compute a quaternion for the given axis vector and angle.

pub fn rotate<C>(self, v: Vector3d<C>) -> F32x3

where C: Component + Into<f32>,

Available on crate feature vector only.

Rotate a 3D vector using this quaternion, assumes the quaternion is of unit length.

pub fn scale<S>(self, scalar: S) -> Self

where S: Into<f32>,

Scale by a scalar.

pub fn normalize(self) -> Self

Normalize the quaternion.

pub fn to_euler(&self) -> (f32, f32, f32)

Get the (roll, pitch, yaw) Euler angles, assumes the quaternion is normalized.

pub fn to_array(&self) -> [f32; 4]

Convert this quaternion into an array.

pub fn w(&self) -> f32

Access the w / a real component

pub fn x(&self) -> f32

Access the x / b / i imaginary component

pub fn y(&self) -> f32

Access the y / c / j imaginary component

pub fn z(&self) -> f32

Access the z / d / k imaginary component

Trait Implementations

impl Add for Quaternion

type Output = Quaternion

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Quaternion

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Quaternion

fn clone(&self) -> Quaternion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Quaternion

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

Formats the value using the given formatter.

impl Default for Quaternion

fn default() -> Self

Returns the “default value” for a type.

impl From<(f32, f32, f32, f32)> for Quaternion

fn from(q: (f32, f32, f32, f32)) -> Quaternion

Converts to this type from the input type.

impl From<Quaternion> for (f32, f32, f32, f32)

fn from(q: Quaternion) -> (f32, f32, f32, f32)

Converts to this type from the input type.

impl<C> From<Vector3d<C>> for Quaternion

where C: Component + Into<f32>,

Available on crate feature vector only.

fn from(v: Vector3d<C>) -> Quaternion

Converts to this type from the input type.

impl Mul<Quaternion> for f32

type Output = Quaternion

The resulting type after applying the * operator.

fn mul(self, q: Quaternion) -> Quaternion

Performs the * operation.

impl<C> Mul<Vector3d<C>> for Quaternion

where C: Component + Into<f32>,

Available on crate feature vector only.

type Output = Vector3d<f32>

The resulting type after applying the * operator.

fn mul(self, v: Vector3d<C>) -> F32x3

Performs the * operation.

impl Mul<f32> for Quaternion

type Output = Quaternion

The resulting type after applying the * operator.

fn mul(self, k: f32) -> Self

Performs the * operation.

impl Mul for Quaternion

type Output = Quaternion

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl MulAssign<f32> for Quaternion

fn mul_assign(&mut self, k: f32)

Performs the *= operation.

impl PartialEq for Quaternion

fn eq(&self, other: &Quaternion) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Sub for Quaternion

type Output = Quaternion

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Quaternion

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Quaternion

impl StructuralPartialEq for Quaternion