Struct wedged::subspace::UnitBlade

#[repr(transparent)]
pub struct UnitBlade<T: AllocBlade<N, G>, N: Dim, G: Dim> { /* private fields */ }

A SimpleBlade with unit length

Primary use is to represent oriented vector spaces of dimension G. If the quantity is going to be stored/cached for an extended period of time, this can also provide an optimization over a SimpleBlade since the length does not have to be accounted for.

Implementations

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> UnitBlade<T, N, G>

pub fn basis_generic(n: N, g: G, i: usize) -> Self where
    T: Zero + One, 

Returns the ith basis element or panics if i is out of range

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> UnitBlade<T, N, G>

pub fn into_inner(self) -> Blade<T, N, G>

Unrwaps self into its internal algebraic type

pub fn as_inner(&self) -> &Blade<T, N, G>

Unrwaps self into a reference to its internal algebraic type

pub fn from_inner_unchecked(b: Blade<T, N, G>) -> Self

Creates a new value of Self from an internal algebraic type assuming that it satisfies all the guarrantees of this type

Safety

This function is not marked unsafe since there is no way an invalid argument could violate any of Rust’s memory safety rules. However, caution should still be taken since an invalid input can still dramatically break many other functions of this type.

impl<T: AllocBlade<N, G> + Neg<Output = T>, N: Dim, G: Dim> UnitBlade<T, N, G>

pub fn reverse(self) -> Self

Reverses the order of the vectors in each basis blade

pub fn involute(self) -> Self

Negates self of each component with an odd grade

pub fn inverse(self) -> Self

The multiplicative inverse of this element

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> UnitBlade<T, N, G>

pub fn project<B>(&self, b: B) -> <Self as Project<B>>::Output where
    Self: Project<B>, 

Finds the parallel component of b onto self

pub fn reject<B>(&self, b: B) -> <Self as Reject<B>>::Output where
    Self: Reject<B>, 

impl<T: AllocBlade<N, U1>, N: Dim> UnitBlade<T, N, Const<1_usize>>

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

Reflects about self

impl<T: AllocBlade<N, U1> + RefRealField, N: Dim> UnitBlade<T, N, Const<1_usize>>

pub fn rot_to(self, v2: UnitVecN<T, N>) -> Rotor<T, N> where
    T: AllocEven<N>, 

impl<T: AllocBlade<N1, G> + Zero, N1: Dim, G: Dim> UnitBlade<T, N1, G>

pub fn cast_dim_generic_unchecked<N2: Dim>(self, n: N2) -> UnitBlade<T, N2, G> where
    T: AllocBlade<N2, G>, 

Embeds self into a different dimension by either removing elements or inserting zeros

pub fn cast_dim_dyn_unchecked(self, n: usize) -> UnitBlade<T, Dynamic, G> where
    T: AllocBlade<Dynamic, G>, 

Embeds self into a different dimension by either removing elements or inserting zeros

pub fn cast_dim_unchecked<N2: DimName>(self) -> UnitBlade<T, N2, G> where
    T: AllocBlade<N2, G>, 

Embeds self into a different dimension by either removing elements or inserting zeros

pub fn cast_dim<N2: DimName>(self) -> UnitBlade<T, N2, G> where
    T: AllocBlade<N2, G>,
    N1: IsLessOrEqual<N2, Output = True>, 

Embeds self into a different dimension by either removing elements or inserting zeros

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> UnitBlade<T, N, G>

pub fn into_blade(self) -> Blade<T, N, G>

pub fn into_simple(self) -> SimpleBlade<T, N, G>

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> UnitBlade<T, N, G> where
    N: DimSub<G>,
    T: AllocBlade<N, DimDiff<N, G>> + Neg<Output = T>, 

pub fn dual(self) -> UnitDualBlade<T, N, G>

Finds the dual of this unit blade. See Blade::dual() for more information

pub fn undual(self) -> UnitDualBlade<T, N, G>

Finds the inverse dual of this unit blade. See Blade::undual() for more information

impl<T: AllocBlade<N, N>, N: DimName> UnitBlade<T, N, N>

pub fn unit_psuedoscalar() -> Self where
    T: One, 

Returns the unit psuedoscalar in dimension N

Methods from Deref<Target = Blade<T, N, G>>

pub fn dim_generic(&self) -> N

Returns the dimension of this value as an instance of the generic type N

This is mostly used internally to unify the codebase between Const dimensions and Dynamic dimensions. Since Dynamic grades often require a usize input when Const grades do not, this allows a function to take a ZST for static dimensions and to take a numeric value for dynamic ones

pub fn grade_generic(&self) -> G

Returns the grade of this Blade as an instance of the generic type G

This is mostly used internally to unify the codebase between Const grades and Dynamic grades. Since Dynamic grades often require a usize input when Const grades do not, this allows a function to take a ZST for static Blades and to take a numeric value for dynamic ones

pub fn dim(&self) -> usize

The number of dimensions this value resides in

Note that this differs from both the grade and number of elements. Instead, this describes the dimension of the vector space generating the algebra this blade resides in.

Examples

//All of these live in 3-dimensions
let v = Vec3::new(3, 1, 4);
let b = BiVec3::new(6, 2, 8);
let r = Even3::new(1, 6, 1, 8);
let m = Multivector3::new(0, 5, 7, 7, 2, 1, 5, 6);

assert_eq!(v.dim(), 3);
assert_eq!(b.dim(), 3);
assert_eq!(r.dim(), 3);
assert_eq!(m.dim(), 3);

//whereas these are in 4D
let v = Vec4::from_element(6);
let b = BiVec4::from_element(2);
let r = Even4::from_element(8);
let m = Multivector4::from_element(3);

assert_eq!(v.dim(), 4);
assert_eq!(b.dim(), 4);
assert_eq!(r.dim(), 4);
assert_eq!(m.dim(), 4);

pub fn grade(&self) -> usize

The grade of this blade

This describes the “dimension” of the vector space this blade represents. Note that this is completely different that the dimension of the blade which describes the the dimension of the surrounding space the blade lives in.

More concretely, the grade is the number of vector basis elements multiplied together to get a basis of this blade. So to get a blade of grade 3, you would need to wedge three vectors together.

Examples

//All vectors are grade 1
let v1 = Vec3::new(6, 2, 8);
let v2 = Vec6::new(6, 2, 8, 3, 1, 8);
let v3 = VecD::from_element(2, 0.0);

assert_eq!(v1.grade(), 1);
assert_eq!(v2.grade(), 1);
assert_eq!(v3.grade(), 1);

//All Bivectors are grade 2
let b1 = BiVec4::new(6, 2, 8, 3, 1, 8);
let b2 = BiVecD::from_element(3, 0.0);

assert_eq!(b1.grade(), 2);
assert_eq!(b2.grade(), 2);

//Dynamic blades
let blade1 = Blade6::from_element(5, 0.0);
let blade2 = BladeD::from_element(4, 3, 0.0);

assert_eq!(blade1.grade(), 5);
assert_eq!(blade2.grade(), 3);

pub fn elements(&self) -> usize

The number of coordinates this value has

Note that for all values besides vectors and psuedovectors, this is completely different than the dimension which instead measures the dimension of the space the value lives in.

• For blades, this value is equal to number of combinations of size self.grade() you can make from self.dim() basis vectors, ie binom(self.dim(), self.grade()).
• For even values, the number of elements is 2^(self.dim()-1) with the exception of 1 when the dimension is 0
• For general multivectors, there are 2^self.dim() components

Finally, note that in all cases, the value returned is either a compile-time constant or cached as the length of some array, so there is no computational overhead to this function.

Examples

let v = Vec4::from_element(0);
let b = BiVec4::from_element(0);
let r = Even4::from_element(0);
let m = Multivector4::from_element(0);

assert_eq!(v.elements(), 4); // (4 choose 1) = 4
assert_eq!(b.elements(), 6); // (4 choose 2) = 6
assert_eq!(r.elements(), 8); // 2^(4-1) = 8
assert_eq!(m.elements(), 16); // 2^4 = 16

pub fn as_slice(&self) -> &[T]

Borrows the components of this value as a slice

pub fn iter(&self) -> Iter<'_, T>

Creates an iterator over references of each component

pub fn even(&self) -> bool

True if the grade if this blade is even

pub fn odd(&self) -> bool

True if the grade if this blade is odd

pub fn pos_sig(&self) -> bool

True if blades if this grade square to positive numbers

pub fn neg_sig(&self) -> bool

True if blades if this grade square to negative numbers

pub fn shape_eq<T2: AllocBlade<N2, G2>, N2: Dim, G2: Dim>(
    &self,
    rhs: &Blade<T2, N2, G2>
) -> bool

Determines if the dimension and grade of two Blades are equal

pub fn norm_sqrd(&self) -> T::AllOutput where
    T: AllRefMul<T>,
    T::AllOutput: AddMonoid, 

The sum of squares of each element

Note that this does not take into account the conjugate of any complex elements. This is by explicit design:

1. We can relax the ComplexField requirement and have more possibilies for scalars types (like polynomials!).
2. For vectors, this should give the quadradic form of the Clifford algebra, but the function Q(z) = zz̅ is not a valid quadradic form^†

pub fn norm(&self) -> T::AllOutput where
    T: AllRefMul<T>,
    T::AllOutput: RealField, 

The square root of the sum of squares of each element

As with norm_squared, this does not take into account the complex conjugate even though ComplexField is a requirement.

pub fn project<B>(&self, b: B) -> <Self as Project<B>>::Output where
    Self: Project<B>, 

Finds the parallel component of b onto self

pub fn reject<B>(&self, b: B) -> <Self as Reject<B>>::Output where
    Self: Reject<B>, 

Finds the perpendicular component of b onto self

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

Reflects about self

Trait Implementations

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> AbsDiffEq<Blade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + AbsDiffEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

type Epsilon = T1::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T1::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, rhs: &Blade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, rhs: &Blade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> AbsDiffEq<SimpleBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + AbsDiffEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

type Epsilon = T1::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T1::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(
    &self,
    rhs: &SimpleBlade<T2, N2, G2>,
    epsilon: T1::Epsilon
) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(
    &self,
    rhs: &SimpleBlade<T2, N2, G2>,
    epsilon: T1::Epsilon
) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> AbsDiffEq<UnitBlade<T2, N2, G2>> for Blade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + AbsDiffEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

type Epsilon = T1::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T1::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, rhs: &UnitBlade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, rhs: &UnitBlade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> AbsDiffEq<UnitBlade<T2, N2, G2>> for SimpleBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + AbsDiffEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

type Epsilon = T1::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T1::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, rhs: &UnitBlade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, rhs: &UnitBlade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> AbsDiffEq<UnitBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + AbsDiffEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

type Epsilon = T1::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T1::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, rhs: &UnitBlade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, rhs: &UnitBlade<T2, N2, G2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> AsRef<[T]> for UnitBlade<T, N, G>

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

Performs the conversion.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> AsRef<Blade<T, N, G>> for UnitBlade<T, N, G>

fn as_ref(&self) -> &Blade<T, N, G>

Performs the conversion.

impl<'a, T: AllocBlade<N, G> + Binary, N: Dim, G: Dim> Binary for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Borrow<[T]> for UnitBlade<T, N, G>

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

Immutably borrows from an owned value.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Borrow<Blade<T, N, G>> for UnitBlade<T, N, G>

fn borrow(&self) -> &Blade<T, N, G>

Immutably borrows from an owned value.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Clone for UnitBlade<T, N, G> 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<'a, T: AllocBlade<N, G> + Debug, N: Dim, G: Dim> Debug for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Deref for UnitBlade<T, N, G>

type Target = Blade<T, N, G>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T: AllocBlade<N, G> + Display, N: Dim, G: Dim> Display for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<'b, T1, T2, U, N: Dim, G: Dim> Div<&'b Reflector<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Div<&'b Reflector<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Div<&'b Rotor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Div<&'b Rotor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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 Rotor<T1, N> where
    T1: AllocEven<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 Rotor<T1, N> where
    T1: AllocEven<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 UnitBlade<T2, N, G>> for Reflector<T1, N> where
    T1: AllocOdd<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 Reflector<T1, N> where
    T1: AllocOdd<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 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, G1: Dim, G2: Dim> Div<&'b UnitBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2> + 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, G2>) -> Versor<U, N>

Performs the / operation.

impl<'a, 'b, T1, T2, U, N: Dim, G1: Dim, G2: Dim> Div<&'b UnitBlade<T2, N, G2>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2> + 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, G2>) -> 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<T1, T2, U, N: Dim, G: Dim> Div<Reflector<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Div<Reflector<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Div<Rotor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Div<Rotor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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 Rotor<T1, N> where
    T1: AllocEven<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 Rotor<T1, N> where
    T1: AllocEven<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<UnitBlade<T2, N, G>> for Reflector<T1, N> where
    T1: AllocOdd<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 Reflector<T1, N> where
    T1: AllocOdd<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<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, G1: Dim, G2: Dim> Div<UnitBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2> + 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, G2>) -> Versor<U, N>

Performs the / operation.

impl<'a, T1, T2, U, N: Dim, G1: Dim, G2: Dim> Div<UnitBlade<T2, N, G2>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2> + 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, G2>) -> 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<'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<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<'a, T: AllocBlade<N, G>, N: Dim, G: Dim> From<&'a UnitBlade<T, N, G>> for &'a Blade<T, N, G>

fn from(x: &'a UnitBlade<T, N, G>) -> &'a Blade<T, N, G>

Performs the conversion.

impl<'a, T: AllocBlade<N, G>, N: Dim, G: Dim> From<&'a mut UnitBlade<T, N, G>> for &'a mut Blade<T, N, G>

fn from(x: &'a mut UnitBlade<T, N, G>) -> &'a mut Blade<T, N, G>

Performs the conversion.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> From<UnitBlade<T, N, G>> for Blade<T, N, G>

fn from(x: UnitBlade<T, N, G>) -> Blade<T, N, G>

Performs the conversion.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> From<UnitBlade<T, N, G>> for SimpleBlade<T, N, G>

fn from(b: UnitBlade<T, N, G>) -> SimpleBlade<T, N, G>

Performs the conversion.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Hash for UnitBlade<T, N, G> where
    T: Hash, 

fn hash<__HTNG>(&self, __state: &mut __HTNG) where
    __HTNG: 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: AllocBlade<N, G>, N: Dim, G: Dim> Index<usize> for UnitBlade<T, N, G>

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> IntoIterator for UnitBlade<T, N, G>

type Item = T

The type of the elements being iterated over.

type IntoIter = <Blade<T, N, G> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: AllocBlade<N, G>, N: Dim, G: Dim> IntoIterator for &'a UnitBlade<T, N, G>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, N: Dim, G: Dim> Inv for UnitBlade<T, N, G> where
    T: AllocBlade<N, G>,
    T: Neg<Output = T>, 

type Output = UnitBlade<T, N, G>

The result after applying the operator.

fn inv(self) -> UnitBlade<T, N, G>

Returns the multiplicative inverse of self.

impl<'a, T, N: Dim, G: Dim> Inv for &'a UnitBlade<T, N, G> where
    T: AllocBlade<N, G>,
    T: Clone + Neg<Output = T>,
    UnitBlade<T, N, G>: Clone, 

type Output = UnitBlade<T, N, G>

The result after applying the operator.

fn inv(self) -> UnitBlade<T, N, G>

Returns the multiplicative inverse of self.

impl<'a, T: AllocBlade<N, G> + LowerExp, N: Dim, G: Dim> LowerExp for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<'a, T: AllocBlade<N, G> + LowerHex, N: Dim, G: Dim> LowerHex for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<'b, T1, T2, U, N: Dim, G: Dim> Mul<&'b Reflector<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Mul<&'b Reflector<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Mul<&'b Rotor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Mul<&'b Rotor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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 Rotor<T1, N> where
    T1: AllocEven<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 Rotor<T1, N> where
    T1: AllocEven<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, G: Dim> Mul<&'b UnitBlade<T2, N, G>> for Reflector<T1, N> where
    T1: AllocOdd<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 Reflector<T1, N> where
    T1: AllocOdd<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, 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, G1: Dim, G2: Dim> Mul<&'b UnitBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitBlade<T2, N, G2>) -> 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<T1, T2, U, N: Dim, G: Dim> Mul<Reflector<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Mul<Reflector<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Mul<Rotor<T2, N>> for UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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, G: Dim> Mul<Rotor<T2, N>> for &'a UnitBlade<T1, N, G> where
    T1: AllocBlade<N, G> + 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 Rotor<T1, N> where
    T1: AllocEven<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 Rotor<T1, N> where
    T1: AllocEven<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, G: Dim> Mul<UnitBlade<T2, N, G>> for Reflector<T1, N> where
    T1: AllocOdd<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 Reflector<T1, N> where
    T1: AllocOdd<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, 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, G1: Dim, G2: Dim> Mul<UnitBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocVersor<N> + AddGroup, 

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitBlade<T2, N, G2>) -> 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<'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<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<T, U, N: Dim, G: Dim> Neg for UnitBlade<T, N, G> where
    T: AllocBlade<N, G>,
    U: AllocBlade<N, G>,
    T: Neg<Output = U>, 

type Output = UnitBlade<U, N, G>

The resulting type after applying the - operator.

fn neg(self) -> UnitBlade<U, N, G>

Performs the unary - operation.

impl<'a, T, U, N: Dim, G: Dim> Neg for &'a UnitBlade<T, N, G> where
    T: AllocBlade<N, G>,
    U: AllocBlade<N, G>,
    T: RefNeg<'a, Output = U>, 

type Output = UnitBlade<U, N, G>

The resulting type after applying the - operator.

fn neg(self) -> UnitBlade<U, N, G>

Performs the unary - operation.

impl<'a, T: AllocBlade<N, G> + Octal, N: Dim, G: Dim> Octal for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> PartialEq<Blade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + PartialEq<T2>,
    T2: AllocBlade<N2, G2>, 

fn eq(&self, rhs: &Blade<T2, N2, G2>) -> bool

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

fn ne(&self, rhs: &Blade<T2, N2, G2>) -> bool

This method tests for !=.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> PartialEq<SimpleBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + PartialEq<T2>,
    T2: AllocBlade<N2, G2>, 

fn eq(&self, rhs: &SimpleBlade<T2, N2, G2>) -> bool

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

fn ne(&self, rhs: &SimpleBlade<T2, N2, G2>) -> bool

This method tests for !=.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> PartialEq<UnitBlade<T2, N2, G2>> for Blade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + PartialEq<T2>,
    T2: AllocBlade<N2, G2>, 

fn eq(&self, rhs: &UnitBlade<T2, N2, G2>) -> bool

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

fn ne(&self, rhs: &UnitBlade<T2, N2, G2>) -> bool

This method tests for !=.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> PartialEq<UnitBlade<T2, N2, G2>> for SimpleBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + PartialEq<T2>,
    T2: AllocBlade<N2, G2>, 

fn eq(&self, rhs: &UnitBlade<T2, N2, G2>) -> bool

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

fn ne(&self, rhs: &UnitBlade<T2, N2, G2>) -> bool

This method tests for !=.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> PartialEq<UnitBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + PartialEq<T2>,
    T2: AllocBlade<N2, G2>, 

fn eq(&self, rhs: &UnitBlade<T2, N2, G2>) -> bool

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

fn ne(&self, rhs: &UnitBlade<T2, N2, G2>) -> bool

This method tests for !=.

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<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, N: Dim, G1: Dim, G2: Dim> Project<Blade<T, N, G2>> for UnitBlade<T, N, G1> where
    G2: DimSymSub<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSymDiff<G2, G1>> + RefDivRing, 

type Output = Blade<T, N, G2>

fn project(&self, b: Blade<T, N, G2>) -> Blade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Project<SimpleBlade<T, N, G2>> for UnitBlade<T, N, G1> where
    G2: DimSymSub<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSymDiff<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn project(&self, b: SimpleBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Project<UnitBlade<T, N, G2>> for Blade<T, N, G1> where
    G2: DimSymSub<G1>,
    T: AllocBlade<N, G1> + AllocSimpleBlade<N, G2> + AllocBlade<N, DimSymDiff<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn project(&self, b: UnitBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Project<UnitBlade<T, N, G2>> for SimpleBlade<T, N, G1> where
    G2: DimSymSub<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSymDiff<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn project(&self, b: UnitBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Project<UnitBlade<T, N, G2>> for UnitBlade<T, N, G1> where
    G2: DimSymSub<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSymDiff<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn project(&self, b: UnitBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Reject<Blade<T, N, G2>> for UnitBlade<T, N, G1> where
    G2: DimAdd<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSum<G2, G1>> + RefDivRing, 

type Output = Blade<T, N, G2>

fn reject(&self, b: Blade<T, N, G2>) -> Blade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Reject<SimpleBlade<T, N, G2>> for UnitBlade<T, N, G1> where
    G2: DimAdd<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSum<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn reject(&self, b: SimpleBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Reject<UnitBlade<T, N, G2>> for Blade<T, N, G1> where
    G2: DimAdd<G1>,
    T: AllocBlade<N, G1> + AllocSimpleBlade<N, G2> + AllocBlade<N, DimSum<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn reject(&self, b: UnitBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Reject<UnitBlade<T, N, G2>> for SimpleBlade<T, N, G1> where
    G2: DimAdd<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSum<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn reject(&self, b: UnitBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Reject<UnitBlade<T, N, G2>> for UnitBlade<T, N, G1> where
    G2: DimAdd<G1>,
    T: AllocBlade<N, G1> + AllocBlade<N, G2> + AllocBlade<N, DimSum<G2, G1>> + RefDivRing, 

type Output = SimpleBlade<T, N, G2>

fn reject(&self, b: UnitBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> RelativeEq<Blade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + RelativeEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_relative() -> T1::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    rhs: &Blade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    rhs: &Blade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> RelativeEq<SimpleBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + RelativeEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_relative() -> T1::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    rhs: &SimpleBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    rhs: &SimpleBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> RelativeEq<UnitBlade<T2, N2, G2>> for Blade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + RelativeEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_relative() -> T1::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> RelativeEq<UnitBlade<T2, N2, G2>> for SimpleBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + RelativeEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_relative() -> T1::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> RelativeEq<UnitBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + RelativeEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_relative() -> T1::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> UlpsEq<Blade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + UlpsEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    rhs: &Blade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(
    &self,
    rhs: &Blade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> UlpsEq<SimpleBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + UlpsEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    rhs: &SimpleBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(
    &self,
    rhs: &SimpleBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> UlpsEq<UnitBlade<T2, N2, G2>> for Blade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + UlpsEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> UlpsEq<UnitBlade<T2, N2, G2>> for SimpleBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + UlpsEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> UlpsEq<UnitBlade<T2, N2, G2>> for UnitBlade<T1, N1, G1> where
    T1: AllocBlade<N1, G1> + UlpsEq<T2>,
    T2: AllocBlade<N2, G2>,
    T1::Epsilon: Clone, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(
    &self,
    rhs: &UnitBlade<T2, N2, G2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<'a, T: AllocBlade<N, G> + UpperExp, N: Dim, G: Dim> UpperExp for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

impl<'a, T: AllocBlade<N, G> + UpperHex, N: Dim, G: Dim> UpperHex for UnitBlade<T, N, G>

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

Formats the value using the given formatter.

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

type Output = Blade<U, N, G2>

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

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

type Output = Blade<U, N, G2>

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

impl<'b, T1, T2, U, N: Dim, G1: Dim> VersorMul<&'b Even<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Even<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Multivector<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Multivector<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Odd<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Odd<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Reflector<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Reflector<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Rotor<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<&'b Rotor<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim, G2: Dim> VersorMul<&'b SimpleBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = SimpleBlade<U, N, G2>

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

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

type Output = SimpleBlade<U, N, G2>

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

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, G1: Dim, G2: Dim> VersorMul<&'b UnitBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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<T1, T2, U, N: Dim, G1: Dim, G2: Dim> VersorMul<Blade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Blade<U, N, G2>

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

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

type Output = Blade<U, N, G2>

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

impl<T1, T2, U, N: Dim, G1: Dim> VersorMul<Even<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Even<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Multivector<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Multivector<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Odd<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Odd<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Reflector<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Reflector<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Rotor<T2, N>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim> VersorMul<Rotor<T2, N>> for &'a UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + 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, G1: Dim, G2: Dim> VersorMul<SimpleBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = SimpleBlade<U, N, G2>

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

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

type Output = SimpleBlade<U, N, G2>

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

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, G1: Dim, G2: Dim> VersorMul<UnitBlade<T2, N, G2>> for UnitBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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<T: AllocBlade<N, G>, N: Dim, G: Dim> Copy for UnitBlade<T, N, G> where
    T: Copy,
    Blade<T, N, G>: Copy, 

impl<T: AllocBlade<N, G> + Eq, N: Dim, G: Dim> Eq for UnitBlade<T, N, G>