Enum wedged::subspace::Versor

pub enum Versor<T: AllocVersor<N>, N: Dim> {
    Even(Rotor<T, N>),
    Odd(Reflector<T, N>),
}

A general orthogonal transformation in N dimensions

Variants

Even(Rotor<T, N>)

Odd(Reflector<T, N>)

Implementations

impl<T: AllocVersor<N>, N: Dim> Versor<T, N>

pub fn dim(&self) -> usize

The dimension of this Versor

pub fn dim_generic(&self) -> N

The dimension of this Versor as the generic type

Useful for generic code that needs to support both static and dynamic dimensions

impl<T: AllocVersor<N> + Neg<Output = T>, N: Dim> Versor<T, N>

pub fn reverse(self) -> Self

Reverses the order of the vectors in each basis blade

Wraps Even::reverse() and Odd::reverse()

pub fn involute(self) -> Self

Negates self if odd

Wraps Rotor::involute() and Reflector::involute()

pub fn inverse(self) -> Self

The multiplicative inverse of this element

Wraps Rotor::inverse() and Reflector::inverse()

impl<T: AllocVersor<N>, N: Dim> Versor<T, N>

pub fn one_generic(n: N) -> Self where
    T: One + Zero, 

impl<T: AllocVersor<Dynamic>> Versor<T, Dynamic>

pub fn one_dyn(n: usize) -> Self where
    T: One + Zero, 

impl<T: AllocVersor<N> + RefUnitRing, N: Dim> Versor<T, N>

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

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

impl<T: AllocVersor<N>, N: Dim> Versor<T, N>

pub fn apply<'a, M>(&'a self, m: M) -> <&'a Self as VersorMul<M>>::Output where
    &'a Self: VersorMul<M>, 

Applies the reflection and rotations of self

impl<T: AllocVersor<N>, N: Dim> Versor<T, N>

pub fn even(&self) -> bool

Returns true if self is an even versor

pub fn try_into_even(self) -> Option<Rotor<T, N>>

Converts self into a Rotor if even and returns None otherwise

pub fn unwrap_even(self) -> Rotor<T, N>

Converts self into a Rotor if even and panics otherwise

pub fn odd(&self) -> bool

Returns true if self is an odd versor

pub fn try_into_odd(self) -> Option<Reflector<T, N>>

Converts self into a Reflector if odd and returns None otherwise

pub fn unwrap_odd(self) -> Reflector<T, N>

Converts self into a Reflector if odd and panics otherwise

Trait Implementations

impl<T: AllocEven<N> + AllocOdd<N> + Binary, N: Dim> Binary for Versor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocVersor<N>, N: Dim> Clone for Versor<T, N> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: AllocEven<N> + AllocOdd<N> + Debug, N: Dim> Debug for Versor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocEven<N> + AllocOdd<N> + Display, N: Dim> Display for Versor<T, N>

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

Formats the value using the given formatter.

impl<'b, T1, T2, U, N: Dim> Div<&'b Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Reflector<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim> Div<&'b Reflector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Reflector<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'b, T1, T2, U, N: Dim> Div<&'b Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rotor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim> Div<&'b Rotor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rotor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'b, T1, T2, U, N: Dim, G: Dim> Div<&'b UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> Div<&'b UnitBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the / operation.

impl<'b, T1, T2, U, N: Dim, G: Dim> Div<&'b Versor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> Div<&'b Versor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'b, T1, T2, U, N: Dim> Div<&'b Versor<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim> Div<&'b Versor<T2, N>> for &'a Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'b, T1, T2, U, N: Dim> Div<&'b Versor<T2, N>> for Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim> Div<&'b Versor<T2, N>> for &'a Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'b, T1, T2, U, N: Dim> Div<&'b Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim> Div<&'b Versor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim> Div<Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Reflector<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim> Div<Reflector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Reflector<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim> Div<Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Rotor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim> Div<Rotor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Rotor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim, G: Dim> Div<UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Div<UnitBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim, G: Dim> Div<Versor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Div<Versor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim> Div<Versor<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim> Div<Versor<T2, N>> for &'a Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim> Div<Versor<T2, N>> for Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim> Div<Versor<T2, N>> for &'a Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<T1, T2, U, N: Dim> Div<Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim> Div<Versor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the / operator.

fn div(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, N: Dim> DivAssign<&'a Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocOdd<N> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: &'a Reflector<T2, N>)

Performs the /= operation.

impl<'a, T1, T2, N: Dim> DivAssign<&'a Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocEven<N> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: &'a Rotor<T2, N>)

Performs the /= operation.

impl<'a, T1, T2, N: Dim, G: Dim> DivAssign<&'a UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocBlade<N, G> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: &'a UnitBlade<T2, N, G>)

Performs the /= operation.

impl<'a, T1, T2, N: Dim> DivAssign<&'a Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: &'a Versor<T2, N>)

Performs the /= operation.

impl<T1, T2, N: Dim> DivAssign<Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocOdd<N> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: Reflector<T2, N>)

Performs the /= operation.

impl<T1, T2, N: Dim> DivAssign<Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocEven<N> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: Rotor<T2, N>)

Performs the /= operation.

impl<T1, T2, N: Dim, G: Dim> DivAssign<UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocBlade<N, G> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: UnitBlade<T2, N, G>)

Performs the /= operation.

impl<T1, T2, N: Dim> DivAssign<Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocVersor<N> + Clone + Neg<Output = T2>,
    for<'b> &'b T1: Mul<T2, Output = T1>, 

fn div_assign(&mut self, rhs: Versor<T2, N>)

Performs the /= operation.

impl<T: AllocVersor<N>, N: Dim> From<Reflector<T, N>> for Versor<T, N>

fn from(b: Reflector<T, N>) -> Versor<T, N>

Performs the conversion.

impl<T: AllocVersor<N>, N: Dim> From<Rotor<T, N>> for Versor<T, N>

fn from(b: Rotor<T, N>) -> Versor<T, N>

Performs the conversion.

impl<T: AllocVersor<N>, N: Dim> Hash for Versor<T, N> where
    T: Hash, 

fn hash<__HTN>(&self, __state: &mut __HTN) where
    __HTN: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T, N: Dim> Inv for Versor<T, N> where
    T: AllocVersor<N>,
    T: Neg<Output = T>, 

type Output = Versor<T, N>

The result after applying the operator.

fn inv(self) -> Versor<T, N>

Returns the multiplicative inverse of self.

impl<'a, T, N: Dim> Inv for &'a Versor<T, N> where
    T: AllocVersor<N>,
    T: Clone + Neg<Output = T>,
    Versor<T, N>: Clone, 

type Output = Versor<T, N>

The result after applying the operator.

fn inv(self) -> Versor<T, N>

Returns the multiplicative inverse of self.

impl<T: AllocEven<N> + AllocOdd<N> + LowerExp, N: Dim> LowerExp for Versor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocEven<N> + AllocOdd<N> + LowerHex, N: Dim> LowerHex for Versor<T, N>

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

Formats the value using the given formatter.

impl<'b, T1, T2, U, N: Dim> Mul<&'b Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Reflector<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim> Mul<&'b Reflector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Reflector<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'b, T1, T2, U, N: Dim> Mul<&'b Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Rotor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim> Mul<&'b Rotor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Rotor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'b, T1, T2, U, N: Dim, G: Dim> Mul<&'b UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> Mul<&'b UnitBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the * operation.

impl<'b, T1, T2, U, N: Dim> Mul<&'b Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim> Mul<&'b Versor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'b, T1, T2, U, N: Dim, G: Dim> Mul<&'b Versor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> Mul<&'b Versor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'b, T1, T2, U, N: Dim> Mul<&'b Versor<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim> Mul<&'b Versor<T2, N>> for &'a Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'b, T1, T2, U, N: Dim> Mul<&'b Versor<T2, N>> for Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, 'b, T1, T2, U, N: Dim> Mul<&'b Versor<T2, N>> for &'a Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim> Mul<Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Reflector<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim> Mul<Reflector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Reflector<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim> Mul<Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Rotor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim> Mul<Rotor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Rotor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim, G: Dim> Mul<UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Mul<UnitBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitBlade<T2, N, G>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim> Mul<Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim> Mul<Versor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim, G: Dim> Mul<Versor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Mul<Versor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim> Mul<Versor<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim> Mul<Versor<T2, N>> for &'a Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<T1, T2, U, N: Dim> Mul<Versor<T2, N>> for Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, U, N: Dim> Mul<Versor<T2, N>> for &'a Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

Performs the * operation.

impl<'a, T1, T2, N: Dim> MulAssign<&'a Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocOdd<N>, 

fn mul_assign(&mut self, rhs: &'a Reflector<T2, N>)

Performs the *= operation.

impl<'a, T1, T2, N: Dim> MulAssign<&'a Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocEven<N>, 

fn mul_assign(&mut self, rhs: &'a Rotor<T2, N>)

Performs the *= operation.

impl<'a, T1, T2, N: Dim, G: Dim> MulAssign<&'a UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocBlade<N, G>, 

fn mul_assign(&mut self, rhs: &'a UnitBlade<T2, N, G>)

Performs the *= operation.

impl<'a, T1, T2, N: Dim> MulAssign<&'a Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocVersor<N>, 

fn mul_assign(&mut self, rhs: &'a Versor<T2, N>)

Performs the *= operation.

impl<T1, T2, N: Dim> MulAssign<Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocOdd<N>, 

fn mul_assign(&mut self, rhs: Reflector<T2, N>)

Performs the *= operation.

impl<T1, T2, N: Dim> MulAssign<Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocEven<N>, 

fn mul_assign(&mut self, rhs: Rotor<T2, N>)

Performs the *= operation.

impl<T1, T2, N: Dim, G: Dim> MulAssign<UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocBlade<N, G>, 

fn mul_assign(&mut self, rhs: UnitBlade<T2, N, G>)

Performs the *= operation.

impl<T1, T2, N: Dim> MulAssign<Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = T1> + AddGroup,
    T2: AllocVersor<N>, 

fn mul_assign(&mut self, rhs: Versor<T2, N>)

Performs the *= operation.

impl<T, U, N: Dim> Neg for Versor<T, N> where
    T: AllocVersor<N> + Neg<Output = U>,
    U: AllocVersor<N>, 

type Output = Versor<U, N>

The resulting type after applying the - operator.

fn neg(self) -> Versor<U, N>

Performs the unary - operation.

impl<'a, T, U, N: Dim> Neg for &'a Versor<T, N> where
    T: AllocVersor<N>,
    U: AllocVersor<N>,
    T: RefNeg<'a, Output = U>, 

type Output = Versor<U, N>

The resulting type after applying the - operator.

fn neg(self) -> Versor<U, N>

Performs the unary - operation.

impl<T: AllocEven<N> + AllocOdd<N> + Octal, N: Dim> Octal for Versor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocVersor<N> + AddGroup + Mul<Output = T> + AllRefMul<T, AllOutput = T> + One + PartialEq, N: DimName> One for Versor<T, N>

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: AllocVersor<N> + PartialEq<U>, U: AllocVersor<N>, N: Dim> PartialEq<Versor<U, N>> for Versor<T, N>

fn eq(&self, rhs: &Versor<U, N>) -> bool

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

fn ne(&self, rhs: &Versor<U, N>) -> bool

This method tests for !=.

impl<'a, T, U, N: Dim> Product<&'a Reflector<T, N>> for Versor<U, N> where
    T: AllocOdd<N>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<&'a Reflector<T, N>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = &'a Reflector<T, N>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T, U, N: Dim> Product<&'a Rotor<T, N>> for Versor<U, N> where
    T: AllocEven<N>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<&'a Rotor<T, N>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = &'a Rotor<T, N>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T, U, N: Dim, G: Dim> Product<&'a UnitBlade<T, N, G>> for Versor<U, N> where
    T: AllocBlade<N, G>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<&'a UnitBlade<T, N, G>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = &'a UnitBlade<T, N, G>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T, U, N: Dim> Product<&'a Versor<T, N>> for Versor<U, N> where
    T: AllocVersor<N>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<&'a Versor<T, N>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = &'a Versor<T, N>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, U, N: Dim> Product<Reflector<T, N>> for Versor<U, N> where
    T: AllocOdd<N>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<Reflector<T, N>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = Reflector<T, N>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, U, N: Dim> Product<Rotor<T, N>> for Versor<U, N> where
    T: AllocEven<N>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<Rotor<T, N>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = Rotor<T, N>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, U, N: Dim, G: Dim> Product<UnitBlade<T, N, G>> for Versor<U, N> where
    T: AllocBlade<N, G>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<UnitBlade<T, N, G>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = UnitBlade<T, N, G>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, U, N: Dim> Product<Versor<T, N>> for Versor<U, N> where
    T: AllocVersor<N>,
    U: AllocVersor<N>,
    Versor<U, N>: Mul<Versor<T, N>, Output = Versor<U, N>> + One, 

fn product<I>(i: I) -> Versor<U, N> where
    I: Iterator<Item = Versor<T, N>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T: AllocEven<N> + AllocOdd<N> + UpperExp, N: Dim> UpperExp for Versor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocEven<N> + AllocOdd<N> + UpperHex, N: Dim> UpperHex for Versor<T, N>

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

Formats the value using the given formatter.

impl<'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b Blade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Blade<U, N, G>

fn versor_mul(self, rhs: &'b Blade<T2, N, G>) -> Blade<U, N, G>

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b Blade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Blade<U, N, G>

fn versor_mul(self, rhs: &'b Blade<T2, N, G>) -> Blade<U, N, G>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Even<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Even<U, N>

fn versor_mul(self, rhs: &'b Even<T2, N>) -> Even<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Even<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Even<U, N>

fn versor_mul(self, rhs: &'b Even<T2, N>) -> Even<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Multivector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocMultivector<N>,
    U: AllocMultivector<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Multivector<U, N>

fn versor_mul(self, rhs: &'b Multivector<T2, N>) -> Multivector<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Multivector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocMultivector<N>,
    U: AllocMultivector<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Multivector<U, N>

fn versor_mul(self, rhs: &'b Multivector<T2, N>) -> Multivector<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Odd<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Odd<U, N>

fn versor_mul(self, rhs: &'b Odd<T2, N>) -> Odd<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Odd<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Odd<U, N>

fn versor_mul(self, rhs: &'b Odd<T2, N>) -> Odd<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Reflector<U, N>

fn versor_mul(self, rhs: &'b Reflector<T2, N>) -> Reflector<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Reflector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Reflector<U, N>

fn versor_mul(self, rhs: &'b Reflector<T2, N>) -> Reflector<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Rotor<U, N>

fn versor_mul(self, rhs: &'b Rotor<T2, N>) -> Rotor<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Rotor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Rotor<U, N>

fn versor_mul(self, rhs: &'b Rotor<T2, N>) -> Rotor<U, N>

impl<'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b SimpleBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = SimpleBlade<U, N, G>

fn versor_mul(self, rhs: &'b SimpleBlade<T2, N, G>) -> SimpleBlade<U, N, G>

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b SimpleBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = SimpleBlade<U, N, G>

fn versor_mul(self, rhs: &'b SimpleBlade<T2, N, G>) -> SimpleBlade<U, N, G>

impl<'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = UnitBlade<U, N, G>

fn versor_mul(self, rhs: &'b UnitBlade<T2, N, G>) -> UnitBlade<U, N, G>

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b UnitBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = UnitBlade<U, N, G>

fn versor_mul(self, rhs: &'b UnitBlade<T2, N, G>) -> UnitBlade<U, N, G>

impl<'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b Versor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> VersorMul<&'b Versor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Versor<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Versor<T2, N>> for &'a Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Versor<T2, N>> for Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Versor<T2, N>> for &'a Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'b, T1, T2, U, N: Dim> VersorMul<&'b Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<'a, 'b, T1, T2, U, N: Dim> VersorMul<&'b Versor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: &'b Versor<T2, N>) -> Versor<U, N>

impl<T1, T2, U, N: Dim, G: Dim> VersorMul<Blade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Blade<U, N, G>

fn versor_mul(self, rhs: Blade<T2, N, G>) -> Blade<U, N, G>

impl<'a, T1, T2, U, N: Dim, G: Dim> VersorMul<Blade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Blade<U, N, G>

fn versor_mul(self, rhs: Blade<T2, N, G>) -> Blade<U, N, G>

impl<T1, T2, U, N: Dim> VersorMul<Even<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Even<U, N>

fn versor_mul(self, rhs: Even<T2, N>) -> Even<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Even<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Even<U, N>

fn versor_mul(self, rhs: Even<T2, N>) -> Even<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Multivector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocMultivector<N>,
    U: AllocMultivector<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Multivector<U, N>

fn versor_mul(self, rhs: Multivector<T2, N>) -> Multivector<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Multivector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocMultivector<N>,
    U: AllocMultivector<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Multivector<U, N>

fn versor_mul(self, rhs: Multivector<T2, N>) -> Multivector<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Odd<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Odd<U, N>

fn versor_mul(self, rhs: Odd<T2, N>) -> Odd<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Odd<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Odd<U, N>

fn versor_mul(self, rhs: Odd<T2, N>) -> Odd<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Reflector<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Reflector<U, N>

fn versor_mul(self, rhs: Reflector<T2, N>) -> Reflector<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Reflector<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocOdd<N>,
    U: AllocOdd<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Reflector<U, N>

fn versor_mul(self, rhs: Reflector<T2, N>) -> Reflector<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Rotor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Rotor<U, N>

fn versor_mul(self, rhs: Rotor<T2, N>) -> Rotor<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Rotor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Rotor<U, N>

fn versor_mul(self, rhs: Rotor<T2, N>) -> Rotor<U, N>

impl<T1, T2, U, N: Dim, G: Dim> VersorMul<SimpleBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = SimpleBlade<U, N, G>

fn versor_mul(self, rhs: SimpleBlade<T2, N, G>) -> SimpleBlade<U, N, G>

impl<'a, T1, T2, U, N: Dim, G: Dim> VersorMul<SimpleBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = SimpleBlade<U, N, G>

fn versor_mul(self, rhs: SimpleBlade<T2, N, G>) -> SimpleBlade<U, N, G>

impl<T1, T2, U, N: Dim, G: Dim> VersorMul<UnitBlade<T2, N, G>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = UnitBlade<U, N, G>

fn versor_mul(self, rhs: UnitBlade<T2, N, G>) -> UnitBlade<U, N, G>

impl<'a, T1, T2, U, N: Dim, G: Dim> VersorMul<UnitBlade<T2, N, G>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G>,
    U: AllocBlade<N, G> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = UnitBlade<U, N, G>

fn versor_mul(self, rhs: UnitBlade<T2, N, G>) -> UnitBlade<U, N, G>

impl<T1, T2, U, N: Dim, G: Dim> VersorMul<Versor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<'a, T1, T2, U, N: Dim, G: Dim> VersorMul<Versor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Versor<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Versor<T2, N>> for &'a Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Versor<T2, N>> for Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Versor<T2, N>> for &'a Reflector<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<T1, T2, U, N: Dim> VersorMul<Versor<T2, N>> for Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<'a, T1, T2, U, N: Dim> VersorMul<Versor<T2, N>> for &'a Versor<T1, N> where
    T1: AllocVersor<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocVersor<N>,
    U: AllocVersor<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Versor<U, N>

fn versor_mul(self, rhs: Versor<T2, N>) -> Versor<U, N>

impl<T: AllocVersor<N>, N: Dim> Copy for Versor<T, N> where
    T: Copy,
    Rotor<T, N>: Copy,
    Reflector<T, N>: Copy, 

impl<T: AllocVersor<N> + Eq, N: Dim> Eq for Versor<T, N>