Struct munum::Quaternion

pub struct Quaternion<T: Copy + NumAssign = f32>(/* private fields */);

A quaternion in (x, y, z, w) order, where q = w + xi + yj + zk.

Implementations

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

pub fn new(x: T, y: T, z: T, w: T) -> Self

Creates a new quaternion.

Examples

let q = <Quaternion>::new(1., 2., 3., 4.);
assert_eq!(*q.as_ref(), [1., 2., 3., 4.]);

pub fn from_array(arr: [T; 4]) -> Self

Creates a quaternion from raw array.

Examples

let q = <Quaternion>::from_array([1., 2., 3., 4.]);
assert_eq!(*q.as_ref(), [1., 2., 3., 4.]);

pub fn identity() -> Self

Creates an identity quaternion.

Examples

let q = <Quaternion>::identity();
assert_eq!(*q.as_ref(), [0.0, 0.0, 0.0, 1.0]);

pub fn from_slice(data: &[T]) -> Self

Creates a quaternion from slice.

Examples

let q = <Quaternion>::from_slice(&[1., 2., 3., 4.]);
assert_eq!(*q.as_ref(), [1., 2., 3., 4.]);

impl<T: Copy + FloatOps + NumAssign> Quaternion<T>

pub fn from_axis_angle(axis: Vec3<T>, angle: T) -> Self

Creates a quaternion from a unit axis vector and rotation angle in couterclockwise direction.

Examples

let q = <Quaternion>::from_axis_angle(<Vec3>::from_slice(&[3., 5., 7.]), PI/3.);
let expected = <Quaternion>::from_slice(&[3. * (PI/6.).sin(), 5. * (PI/6.).sin(), 7. * (PI/6.).sin(), (PI/6.).cos()]);
assert_float_eq!(q, expected, 0.00001);

pub fn from_angle_x(angle: T) -> Self

Creates a quaternion from a rotation angle around x-axis in couterclockwise direction.

Examples

let q = <Quaternion>::from_angle_x(PI/3.);
let expected = <Quaternion>::from_slice(&[(PI/6.).sin(), 0., 0., (PI/6.).cos()]);
assert_float_eq!(q, expected, 0.00001);

pub fn from_angle_y(angle: T) -> Self

Creates a quaternion from a rotation angle around x-axis in couterclockwise direction.

Examples

let q = <Quaternion>::from_angle_y(PI/3.);
let expected = <Quaternion>::from_slice(&[0., (PI/6.).sin(), 0., (PI/6.).cos()]);
assert_float_eq!(q, expected, 0.00001);

pub fn from_angle_z(angle: T) -> Self

Creates a quaternion from a rotation angle around x-axis in couterclockwise direction.

Examples

let q = <Quaternion>::from_angle_z(PI/3.);
let expected = <Quaternion>::from_slice(&[0., 0., (PI/6.).sin(), (PI/6.).cos()]);
assert_float_eq!(q, expected, 0.00001);

impl<T: Copy + FloatOps + FloatEq<T> + NumAssign + NumCast + Signed> Quaternion<T>

pub fn from_unit_vecs(from: Vec3<T>, to: Vec3<T>) -> Self

Creates a quaternion that represents the shortest arc rotation between 2 unit vectors.

Examples

let q = <Quaternion>::from_unit_vecs(<Vec3>::from_slice(&[0., 0., 1.]), <Vec3>::from_slice(&[1., 0., 0.]));
let expected = <Quaternion>::from_slice(&[0., (PI/4.).sin(), 0., (PI/4.).cos()]);
assert_float_eq!(q, expected, 0.00001);

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

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

Calculates the dot product of 2 Quaternions.

Examples

let (v1, v2) = (Quaternion::<i32>::from_slice(&[29, 31, 37, 41]), Quaternion::<i32>::from_slice(&[43, 47, 53, 59]));
assert_eq!(v1.dot(v2), 7084);

pub fn sqr_len(&self) -> T

Calculates the square length of a 2 Quaternion.

Examples

assert_eq!(Quaternion::<i32>::from_slice(&[2, 5, 14, 8]).sqr_len(), 289);

pub fn conj(&mut self)

Transforms this Quaternion into its conjugate.

Examples

let mut q = Quaternion::<i32>::from_slice(&[2, 5, 14, 8]);
q.conj();
assert_eq!(*q.as_ref(), [-2, -5, -14, 8]);

pub fn invert(&mut self) -> bool

Inverts this Quaternion.

Examples

let mut q = <Quaternion>::from_slice(&[2., 5., 14., 8.]);
assert!(q.invert());
assert_eq!(*q.as_ref(), [-2. / 289., -5. / 289., -14. / 289., 8. / 289.]);

pub fn rotate_vec3(self, v: Vec3<T>) -> Vec3<T>

Returns the result from rotating given Vec3 by this Quaternion, using the formula v’ = q * v * q^-1. See: https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Using_quaternion_as_rotations

Examples

let q = <Quaternion>::from_slice(&[0., 1./2_f32.sqrt(), 0., 1./2_f32.sqrt()]);
let v = <Vec3>::from_slice(&[1. ,1., 1.]);
assert_eq!(*q.rotate_vec3(v).as_ref(), [1., 1., -1.]);

impl<T: Copy + FloatOps + NumAssign + Signed> Quaternion<T>

pub fn len(&self) -> T

Calculates the length of this Quaternion.

Examples

assert_eq!(<Quaternion>::from_slice(&[2., 5., 14., 8.]).len(), 17.);

pub fn normalize(&mut self) -> bool

Normizalizes this Quaternion.

Examples

let mut q = <Quaternion>::from_slice(&[2., 5., 14., 8.]);
assert!(q.normalize());
assert_float_eq!(q.as_ref(), &[2./17., 5./17., 14./17., 8./17.]);

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

Returns a normalized version of this vector.

Examples

let q = <Quaternion>::from_slice(&[2., 5., 14., 8.]).normalized().unwrap();
assert_float_eq!(q.as_ref(), &[2./17., 5./17., 14./17., 8./17.]);

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

Linear interpolates between 2 unit Quaternions.

Examples

let (q1, q2) = (<Quaternion>::from_slice(&[(PI/4.).sin(), 0., 0., (PI/4.).cos()]), <Quaternion>::from_slice(&[(PI/4.).sin(), 0., 0., -(PI/4.).cos()]));
assert_eq!(*q1.lerp(q2, 0.5).as_ref(), [1., 0., 0., 0.]);

impl<T: Copy + FloatOps + NumAssign + NumCast + Signed> Quaternion<T>

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

Shperical linear interpolates between 2 unit Quaternions.

Examples

let (q1, q2) = (<Quaternion>::from_slice(&[(PI/6.).sin(), 0., 0., (PI/6.).cos()]), <Quaternion>::from_slice(&[-(PI/6.).cos(), 0., 0., -(PI/6.).sin()]));
assert_float_eq!(q1.slerp(q2, 0.5).as_ref(), &[(PI/4.).sin(), 0., 0., (PI/4.).cos()]);

Trait Implementations

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

type Output = Quaternion<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + NumAssign> AddAssign for Quaternion<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Copy + NumAssign> AsMut<[T]> for Quaternion<T>

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: Copy + NumAssign> AsRef<[T]> for Quaternion<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone + Copy + NumAssign> Clone for Quaternion<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy + NumAssign> Debug for Quaternion<T>

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

Formats the value using the given formatter.

impl<T: Copy + NumAssign> Default for Quaternion<T>

fn default() -> Self

Returns the “default value” for a type.

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

where T: Deserialize<'de> + Copy + NumAssign,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Copy + NumAssign> 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: Copy + NumAssign> DivAssign<T> for Quaternion<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Copy + FloatEq<T> + NumAssign> FloatEq<T> for Quaternion<T>

fn float_eq(&self, rhs: Self, epsilon: T) -> bool

Checks if self equals to RHS within an epsilon.

impl<T: Copy + NumAssign> From<&[T]> for Quaternion<T>

fn from(data: &[T]) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T: Copy + NumAssign> From<Matrix<T, 3, 1>> for Quaternion<T>

fn from(v: Vec3<T>) -> Self

Creates a Quaternion from a Vec3 using w = 0.

Examples

let q = Quaternion::from(Vec3::<i32>::from_slice(&[2, 3, 4]));
assert_eq!(*q.as_ref(), [2, 3, 4, 0]);

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

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

Converts to this type from the input type.

impl<T: Copy + NumAssign> From<Quaternion<T>> for Vec3<T>

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

Creates a Vec3 from a Quaternion by dropping the w component.

Examples

let v = Vec3::from(Quaternion::<i32>::from_slice(&[2, 3, 4, 5]));
assert_eq!(*v.as_ref(), [2, 3, 4]);

impl<T: Copy + NumAssign> From<Quaternion<T>> for Mat3<T>

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

Converts a Quaternion into a Mat3

Examples

let ONE_OVER_SQRT3: f32 = 1. / 3_f32.sqrt();
let m = <Mat3>::from(<Quaternion>::from_slice(&[ONE_OVER_SQRT3, ONE_OVER_SQRT3, ONE_OVER_SQRT3, 0.]));
assert_float_eq!(m.as_ref(), &[-1./3., 2./3., 2./3., 2./3., -1./3., 2./3., 2./3., 2./3., -1./3.]);

impl<T: Copy + NumAssign> Index<usize> for Quaternion<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Copy + NumAssign> IndexMut<usize> for Quaternion<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: Copy + NumAssign> 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: Copy + NumAssign> 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: Copy + NumAssign> MulAssign<T> for Quaternion<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Copy + NumAssign> MulAssign for Quaternion<T>

fn mul_assign(&mut self, rhs: Self)

Calculate the Hamilton product of 2

Examples

let mut q = Quaternion::<i32>::from_slice(&[2, 3, 5, -7]);
q *= Quaternion::<i32>::from_slice(&[11, 13, -17, 19]);
assert_eq!(*q.as_ref(), [-155, 55, 207, -109]);

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

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

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 + Copy + NumAssign> PartialEq for Quaternion<T>

fn eq(&self, other: &Quaternion<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 Quaternion<T>

where T: Serialize + Copy + NumAssign,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy + NumAssign> Sub for Quaternion<T>

type Output = Quaternion<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + NumAssign> SubAssign for Quaternion<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Copy + NumAssign> 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 + NumAssign> Copy for Quaternion<T>

impl<T: Copy + NumAssign> StructuralPartialEq for Quaternion<T>