Struct Quaternion

#[repr(C)]
pub struct Quaternion<T> { /* private fields */ }

Quaternion type

Implementations

impl<T> Quaternion<T>

pub const fn new(q0: T, q: V3<T>) -> Self

Construct a new Quaternion from a number(real part) and a vector(imag part)

pub const fn new_from(q0: T, q1: T, q2: T, q3: T) -> Self

Construct a new Quaternion from raw four numbers

impl<T: Num + Copy> Quaternion<T>

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

dot product

pub fn real(&self) -> T

get the real part

pub fn imag(&self) -> V3<T>

get the imaginary part

pub fn one() -> Quaternion<T>

construct a unit Quaternion

pub fn zero() -> Self

construct a zero Quaternion

pub fn new_real(q0: T) -> Self

construct a pure “real” Quaternion

pub fn new_imag(q: &V3<T>) -> Self

construct a pure “imaginary” Quaternion

pub fn abs2(&self) -> T

calculate the abs2 of the Quaternion

pub fn new_from_vec(v: &V4<T>) -> Self

Construct a new Quternion from a V4

pub fn to_rotation(&self) -> M33<T>

convert the Quaternion to a rotation matrix

impl<T: Num + Copy + Signed> Quaternion<T>

pub fn conj(&self) -> Self

impl<T: Float + Sum> Quaternion<T>

pub fn from_rotation(rot: &M33<T>) -> Self

convert a rotation matrix M33 to a Quaternion

impl<T: Float> Quaternion<T>

pub fn norm2(&self) -> T

the euclidean norm of the Quaternion

pub fn normalize(&self) -> Option<Self>

normalize the Quaternion only if necessary

pub fn abs_imag(&self) -> T

get the norm of the “imaginary” part

pub fn rotation(theta: T, vector: &V3<T>) -> Self

generate a Quaternion that represents a rotation of a angle theta around the axis(normalized) v

pub fn rotation_norm_encoded(v: &V3<T>) -> Self

generate a Quaternion that represents a rotation of a angle theta around the axis(normalized) v, the angle theta is encoded in the norm of the vector v

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

create a quaternion that represents the rotation from a Euler angles with the roll-pitch-yay convention

pub fn get_angle(&self) -> T

get the angle of representation from this Quaternion

pub fn get_axis(&self) -> Option<V3<T>>

get the axis of rotation from which this Quaternion represent

pub fn axis_angle(&self) -> (Option<V3<T>>, T)

combine the two previous methods: get_axis and get_angle

pub fn normalize_q(&self) -> Self

normalize the Quaternion

pub fn argq(&self) -> Self

get the argument of the Quaternion

pub fn exp(&self) -> Self

exponential function apply to the current Quaternion

pub fn ln(&self) -> Self

natural logaritmic function apply to the current Quaternion

pub fn sqrt(&self) -> Self

sqrt function apply to the current Quaternion

pub fn pow(&self, rhs: Self) -> Self

power the current Quaternion to the rhs argument

pub fn slerp(a: Self, b: Self, t: T) -> Self

Spherical Linear Interpolation between two Quaternions this implementation follow this implementations:

https://www.mrpt.org/tutorials/programming/maths-and-geometry/slerp-interpolation/

Function arguments:

a: Quaternion(normalized)

b: Quaternion(normalized)

t: Float in the closed interval [0.0, 1.0]

pub fn derivative(&self, rate: &V3<T>) -> Self

Calculate the instantaneous Quaternion derivative representing a Quaternion rotating at rate given by a vector rate

Function arguments:

rate: V3

impl<T: Float + Signed> Quaternion<T>

pub fn inverse(&self) -> Option<Self>

Calculate the inverse of the Quaternion

pub fn sin(&self) -> Self

sin function apply to the current Quaternion

pub fn cos(&self) -> Self

cos function apply to the current Quaternion

impl<T: Float + FloatConst> Quaternion<T>

pub fn to_euler_angles(&self) -> (T, T, T)

get the euler angles from the Quaternion

Trait Implementations

impl<T: Num + Copy> Add for Quaternion<T>

type Output = Quaternion<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for Quaternion<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Quaternion<T>

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

Formats the value using the given formatter.

impl<T: Num + Display> Display for Quaternion<T>

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

Formats the value using the given formatter.

impl<T: Num + Copy> Div<T> for 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: Float + Signed> Div for Quaternion<T>

type Output = Quaternion<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Copy> From<[T; 4]> for Quaternion<T>

fn from(data: [T; 4]) -> Quaternion<T>

Converts to this type from the input type.

impl<T: Num + Copy> Mul<T> for 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: Num + Copy + Signed> Mul<V3<T>> for Quaternion<T>

type Output = V3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num + Copy> Mul for Quaternion<T>

type Output = Quaternion<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num + Copy + Signed> Neg for Quaternion<T>

type Output = Quaternion<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Num + Copy> One for Quaternion<T>

fn one() -> Self

Create an identity Quaternion

fn set_one(&mut self)

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

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T: PartialEq> PartialEq for Quaternion<T>

fn eq(&self, other: &Quaternion<T>) -> 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<T: Num + Copy> Sub for Quaternion<T>

type Output = Quaternion<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Num + Copy> Zero for Quaternion<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Copy> Copy for Quaternion<T>

impl<T> StructuralPartialEq for Quaternion<T>