Struct num_quaternion::Quaternion

pub struct Quaternion<T> {
    pub a: T,
    pub b: T,
    pub c: T,
    pub d: T,
}

Quaternions.

Fields

a: T

Real part of the quaternion.

b: T

The coefficient of i.

c: T

The coefficient of j.

d: T

The coefficient of k.

Implementations

impl<T> Quaternion<T>

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

Create a new quaternion.

impl<T> Quaternion<T>

where T: ConstZero,

pub const ZERO: Self = _

A constant zero Quaternion.

impl<T> Quaternion<T>

where T: ConstZero + ConstOne,

pub const ONE: Self = _

A constant Quaternion of value 1.

pub const I: Self = _

A constant Quaternion of value i.

pub const J: Self = _

A constant Quaternion of value j.

pub const K: Self = _

A constant Quaternion of value k.

impl<T> Quaternion<T>

where T: Zero + One,

pub fn i() -> Self

Returns the imaginary unit i.

See also Quaternion::I.

pub fn j() -> Self

Returns the imaginary unit j.

See also Quaternion::J.

pub fn k() -> Self

Returns the imaginary unit k.

See also Quaternion::K.

impl<T> Quaternion<T>

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

pub fn norm_sqr(&self) -> T

Returns the square of the norm (since T doesn’t necessarily have a sqrt function), i.e. a^2 + b^2 + c^2 + d^2.

impl<T> Quaternion<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> Quaternion<T>

where for<'a> &'a Self: Inv<Output = Quaternion<T>>,

pub fn inv(&self) -> Self

Returns 1/self

impl<T> Quaternion<T>

where T: Float,

pub fn norm(self) -> T

Calculate |self|

impl<T> Quaternion<T>

where T: Num + Clone,

pub fn powu(&self, exp: u32) -> Self

Raises self to an unsigned integer power.

impl<T> Quaternion<T>

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

pub fn powi(&self, exp: i32) -> Self

Raises self to a signed integer power.

Trait Implementations

impl<T> Add<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: T) -> Self::Output

Performs the + operation.

impl<T> Add for Quaternion<T>

where T: Add<T, Output = 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, S> AddAssign<S> for Quaternion<T>

where Self: Add<S, Output = Self> + Clone,

fn add_assign(&mut self, other: S)

Performs the += operation.

impl<T: Clone> 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> ConstOne for Quaternion<T>

where T: ConstZero + ConstOne + Num + Clone,

const ONE: Self = Self::ONE

The multiplicative identity element of Self, 1.

impl<T> ConstZero for Quaternion<T>

where T: ConstZero,

const ZERO: Self = Self::ZERO

The additive identity element of Self, 0.

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

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

Formats the value using the given formatter.

impl<T: Default> Default for Quaternion<T>

fn default() -> Quaternion<T>

Returns the “default value” for a type.

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

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

type Output = Quaternion<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div for Quaternion<T>

where T: Num + Clone + Neg<Output = 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, S> DivAssign<S> for Quaternion<T>

where Self: Div<S, Output = Self> + Clone,

fn div_assign(&mut self, other: S)

Performs the /= operation.

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

where T: Clone + Zero,

fn from(a: &T) -> Self

Converts to this type from the input type.

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

where T: Zero,

fn from(a: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Quaternion<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 &Quaternion<T>

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

type Output = Quaternion<T>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T> Inv for Quaternion<T>

where for<'a> &'a Self: Inv<Output = Quaternion<T>>,

type Output = Quaternion<T>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

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

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

type Output = Quaternion<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for Quaternion<T>

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

type Output = Quaternion<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, S> MulAssign<S> for Quaternion<T>

where Self: Mul<S, Output = Self> + Clone,

fn mul_assign(&mut self, other: S)

Performs the *= operation.

impl<T> Neg for Quaternion<T>

where T: Neg<Output = T>,

type Output = Quaternion<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> One for Quaternion<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 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> Sub<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: T) -> Self::Output

Performs the - operation.

impl<T> Sub for Quaternion<T>

where T: Sub<T, Output = 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, S> SubAssign<S> for Quaternion<T>

where Self: Sub<S, Output = Self> + Clone,

fn sub_assign(&mut self, other: S)

Performs the -= operation.

impl<T> Zero for Quaternion<T>

where T: Zero,

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: Eq> Eq for Quaternion<T>

impl<T> StructuralPartialEq for Quaternion<T>