Struct wedged::subspace::SimpleBlade

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

A Blade that is the wedge product of G vectors

This is usually used to represent weighted vector spaces or when the cost to normalize to a UnitBlade is too high.

Implementations

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> SimpleBlade<T, N, G>

pub fn from_iter_generic<I: IntoIterator<Item = T>>(n: N, g: G, iter: I) -> Self

Constructs a value with elements from an iterator using a generic shape

pub fn from_index_fn_generic<F: FnMut(usize) -> T>(n: N, g: G, f: F) -> Self

Constructs a value from an index function using a generic shape

pub fn from_element_generic(n: N, g: G, x: T) -> Self where
    T: Clone, 

Constructs a value filled with given element using a generic shape

pub fn from_slice_generic(n: N, g: G, data: &[T]) -> Self where
    T: Clone, 

Constructs a value cloned from a slice

pub fn from_vec_generic(n: N, g: G, data: Vec<T>) -> Self where
    T: Clone, 

Constructs a value from a Vec

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

pub fn zeroed_generic(n: N, g: G) -> Self where
    T: Zero, 

Constructs a blade with all components set to zero using a generic shape

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: AllocSimpleBlade<N, G>, N: DimName, G: DimName> SimpleBlade<T, N, G>

pub fn from_iterator<I: IntoIterator<Item = T>>(iter: I) -> Self

Constructs a value using elements from an iterator

Panics if the iterator has too few elements to fill in the blade

Examples

let array = [0, 1, 2, 3, 4, 5];

let v1 = Vec6::from_iterator(0..); //static dim, static grade
let v2 = VecD::from_iterator(6, 0..); //dynamic dim, static grade
let v3 = Blade6::from_iterator(1, 0..); //static dim, dynamic grade
let v4 = BladeD::from_iterator(6, 1, 0..); //dynamic dim, dynamic grade

assert_eq!(v1.as_slice(), &array);
assert_eq!(v2.as_slice(), &array);
assert_eq!(v3.as_slice(), &array);
assert_eq!(v4.as_slice(), &array);

pub fn from_index_fn<F: FnMut(usize) -> T>(f: F) -> Self

Constructs a value using a function mapping an index to an element

Examples

//computes the nth fibonnacci number
fn fib(n: usize) -> usize {
    if n <= 1 {
        1
    } else {
        fib(n-1) + fib(n-2)
    }
}

//5D bivector, so 10 elements
let array = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let b1 = BiVec5::from_index_fn(fib); //static dim, static grade
let b2 = BiVecD::from_index_fn(5, fib); //dynamic dim, static grade
let b3 = Blade5::from_index_fn(2, fib); //static dim, dynamic grade
let b4 = BladeD::from_index_fn(5, 2, fib); //dynamic dim, dynamic grade

assert_eq!(b1.as_slice(), &array);
assert_eq!(b2.as_slice(), &array);
assert_eq!(b3.as_slice(), &array);
assert_eq!(b4.as_slice(), &array);

pub fn from_element(x: T) -> Self where
    T: Clone, 

Constructs a value where every component is the given element

Examples

//4D Trivector, so 4 elements
let array = [6.28; 4];

let t1 = TriVec4::from_element(6.28); //static dim, static grade
let t2 = TriVecD::from_element(4, 6.28); //dynamic dim, static grade
let t3 = Blade4::from_element(3, 6.28); //static dim, dynamic grade
let t4 = BladeD::from_element(4, 3, 6.28); //dynamic dim, dynamic grade

assert_eq!(t1.as_slice(), &array);
assert_eq!(t2.as_slice(), &array);
assert_eq!(t3.as_slice(), &array);
assert_eq!(t4.as_slice(), &array);

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

Constructs an elements by cloning values from a slice

Panics if not enough values are provided

let values = [6, 2, 8, 3];

let v1 = Vec4::from_slice(&values);
let v2 = VecD::from_slice(4, &values);
let q = Even3::from_slice(&values);

assert_eq!(v1.as_slice(), &values);
assert_eq!(v2.as_slice(), &values);
assert_eq!(q.as_slice(), &values);

pub fn from_vec(data: Vec<T>) -> Self where
    T: Clone, 

Constructs an elements by moving values from a Vec

Panics if not enough values are provided

let values = vec![6, 2, 8, 3];

let v1 = Vec4::from_vec(values.clone());
let v2 = VecD::from_vec(4, values.clone());
let q = Even3::from_vec(values.clone());

assert_eq!(v1.as_slice(), &*values);
assert_eq!(v2.as_slice(), &*values);
assert_eq!(q.as_slice(), &*values);

impl<T: AllocBlade<N, G>, N: DimName, G: DimName> SimpleBlade<T, N, G>

pub fn zeroed() -> Self where
    T: Zero, 

Constructs a value with all components set to zero

Examples

let array = [0.0; 4];

let v1 = Vec4::<f64>::zeroed(); //static dim, static grade
let v2 = VecD::<f64>::zeroed(4); //dynamic dim, static grade
let v3 = Blade4::<f64>::zeroed(1); //static dim, dynamic grade
let v4 = BladeD::<f64>::zeroed(4, 1); //dynamic dim, dynamic grade

assert_eq!(v1.as_slice(), &array);
assert_eq!(v2.as_slice(), &array);
assert_eq!(v3.as_slice(), &array);
assert_eq!(v4.as_slice(), &array);

pub fn basis(i: usize) -> Self where
    T: Zero + One, 

Returns an element where the ith value is one and the rest are zeroes

Panics if i is out of range

impl<T: AllocSimpleBlade<Dynamic, G>, G: DimName> SimpleBlade<T, Dynamic, G>

pub fn from_iterator<I: IntoIterator<Item = T>>(n: usize, iter: I) -> Self

Constructs a value using elements from an iterator

Panics if the iterator has too few elements to fill in the blade

Examples

let array = [0, 1, 2, 3, 4, 5];

let v1 = Vec6::from_iterator(0..); //static dim, static grade
let v2 = VecD::from_iterator(6, 0..); //dynamic dim, static grade
let v3 = Blade6::from_iterator(1, 0..); //static dim, dynamic grade
let v4 = BladeD::from_iterator(6, 1, 0..); //dynamic dim, dynamic grade

assert_eq!(v1.as_slice(), &array);
assert_eq!(v2.as_slice(), &array);
assert_eq!(v3.as_slice(), &array);
assert_eq!(v4.as_slice(), &array);

pub fn from_index_fn<F: FnMut(usize) -> T>(n: usize, f: F) -> Self

Constructs a value using a function mapping an index to an element

Examples

//computes the nth fibonnacci number
fn fib(n: usize) -> usize {
    if n <= 1 {
        1
    } else {
        fib(n-1) + fib(n-2)
    }
}

//5D bivector, so 10 elements
let array = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let b1 = BiVec5::from_index_fn(fib); //static dim, static grade
let b2 = BiVecD::from_index_fn(5, fib); //dynamic dim, static grade
let b3 = Blade5::from_index_fn(2, fib); //static dim, dynamic grade
let b4 = BladeD::from_index_fn(5, 2, fib); //dynamic dim, dynamic grade

assert_eq!(b1.as_slice(), &array);
assert_eq!(b2.as_slice(), &array);
assert_eq!(b3.as_slice(), &array);
assert_eq!(b4.as_slice(), &array);

pub fn from_element(n: usize, x: T) -> Self where
    T: Clone, 

Constructs a value where every component is the given element

Examples

//4D Trivector, so 4 elements
let array = [6.28; 4];

let t1 = TriVec4::from_element(6.28); //static dim, static grade
let t2 = TriVecD::from_element(4, 6.28); //dynamic dim, static grade
let t3 = Blade4::from_element(3, 6.28); //static dim, dynamic grade
let t4 = BladeD::from_element(4, 3, 6.28); //dynamic dim, dynamic grade

assert_eq!(t1.as_slice(), &array);
assert_eq!(t2.as_slice(), &array);
assert_eq!(t3.as_slice(), &array);
assert_eq!(t4.as_slice(), &array);

pub fn from_slice(n: usize, data: &[T]) -> Self where
    T: Clone, 

Constructs an elements by cloning values from a slice

Panics if not enough values are provided

let values = [6, 2, 8, 3];

let v1 = Vec4::from_slice(&values);
let v2 = VecD::from_slice(4, &values);
let q = Even3::from_slice(&values);

assert_eq!(v1.as_slice(), &values);
assert_eq!(v2.as_slice(), &values);
assert_eq!(q.as_slice(), &values);

pub fn from_vec(n: usize, data: Vec<T>) -> Self where
    T: Clone, 

Constructs an elements by moving values from a Vec

Panics if not enough values are provided

let values = vec![6, 2, 8, 3];

let v1 = Vec4::from_vec(values.clone());
let v2 = VecD::from_vec(4, values.clone());
let q = Even3::from_vec(values.clone());

assert_eq!(v1.as_slice(), &*values);
assert_eq!(v2.as_slice(), &*values);
assert_eq!(q.as_slice(), &*values);

impl<T: AllocBlade<Dynamic, G>, G: DimName> SimpleBlade<T, Dynamic, G>

pub fn zeroed(n: usize) -> Self where
    T: Zero, 

Constructs a value with all components set to zero

Examples

let array = [0.0; 4];

let v1 = Vec4::<f64>::zeroed(); //static dim, static grade
let v2 = VecD::<f64>::zeroed(4); //dynamic dim, static grade
let v3 = Blade4::<f64>::zeroed(1); //static dim, dynamic grade
let v4 = BladeD::<f64>::zeroed(4, 1); //dynamic dim, dynamic grade

assert_eq!(v1.as_slice(), &array);
assert_eq!(v2.as_slice(), &array);
assert_eq!(v3.as_slice(), &array);
assert_eq!(v4.as_slice(), &array);

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

Returns an element where the ith value is one and the rest are zeroes

Panics if i is out of range

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> SimpleBlade<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: AllocSimpleBlade<N, G>, N: Dim, G: Dim> SimpleBlade<T, N, G>

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

Unwraps self and a mutable reference of its inner algebraic struct

pub fn from_inner(inner: Blade<T, N, G>) -> Self

Creates a new value of Self from its inner algebraic struct

Since T:AllocSimpleBlade<N,G>, this is guarranteed to satisfy all the preconditions of this type

impl<T: AllocBlade<N, G> + Neg<Output = T>, N: Dim, G: Dim> SimpleBlade<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 where
    T: RefDivRing, 

The multiplicative inverse of this element

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

pub fn normalize(self) -> UnitBlade<T, N, G> where
    T: RefRealField, 

Divides self by its norm

pub fn try_normalize(self) -> Option<UnitBlade<T, N, G>> where
    T: RefRealField, 

Divides self by its norm if it is non-zero

pub fn norm_and_normalize(self) -> (T, UnitBlade<T, N, G>) where
    T: RefRealField, 

Normalizes self and returns its norm and normalization

pub fn try_norm_and_normalize(self) -> Option<(T, UnitBlade<T, N, G>)> where
    T: RefRealField, 

Normalizes self and returns its norm and normalization if non-zero

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

impl<T: AllocBlade<N, U1>, N: Dim> SimpleBlade<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, U2> + RefRealField, N: Dim> SimpleBlade<T, N, Const<{_: usize}>>

pub fn exp(self) -> Rotor<T, N> where
    T: AllocEven<N>, 

Computes the exponential of this bivector as a Rotor

This will produce a Rotor that performs a simple rotation in the plane of self by an angle twice the norm of self

This is almost always faster than [BiVecN::exp_rotor()], but can only result in simple rotations.

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

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

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

pub fn cast_dim_generic<N2: Dim>(self, n: N2) -> SimpleBlade<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(self, n: usize) -> SimpleBlade<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<N2: DimName>(self) -> SimpleBlade<T, N2, G> where
    T: AllocBlade<N2, G>, 

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

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

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

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

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

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

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

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

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

impl<T> SimpleBlade<T, Const<1_usize>, Const<1_usize>>

pub const fn new(x: T) -> SimpleVec1<T>

Constructs a SimpleVec1 directly from components

Examples

let arr = [6];
let x = SimpleVec1::new(6);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<1_usize>>

pub const fn new(x: T, y: T) -> SimpleVec2<T>

Constructs a SimpleVec2 directly from components

Examples

let arr = [6, 2];
let x = SimpleVec2::new(6, 2);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<1_usize>>

pub const fn new(x: T, y: T, z: T) -> SimpleVec3<T>

Constructs a SimpleVec3 directly from components

Examples

let arr = [6, 2, 8];
let x = SimpleVec3::new(6, 2, 8);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<1_usize>>

pub const fn new(x: T, y: T, z: T, w: T) -> SimpleVec4<T>

Constructs a SimpleVec4 directly from components

Examples

let arr = [6, 2, 8, 3];
let x = SimpleVec4::new(6, 2, 8, 3);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<1_usize>>

pub const fn new(x: T, y: T, z: T, w: T, a: T) -> SimpleVec5<T>

Constructs a SimpleVec5 directly from components

Examples

let arr = [6, 2, 8, 3, 1];
let x = SimpleVec5::new(6, 2, 8, 3, 1);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<1_usize>>

pub const fn new(x: T, y: T, z: T, w: T, a: T, b: T) -> SimpleVec6<T>

Constructs a SimpleVec6 directly from components

Examples

let arr = [6, 2, 8, 3, 1, 8];
let x = SimpleVec6::new(6, 2, 8, 3, 1, 8);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T, y: T, z: T) -> SimpleBiVec3<T>

Constructs a SimpleBiVec3 directly from components

Examples

let arr = [6, 2, 8];
let x = SimpleBiVec3::new(6, 2, 8);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T, y: T, z: T, w: T) -> SimpleTriVec4<T>

Constructs a SimpleTriVec4 directly from components

Examples

let arr = [6, 2, 8, 3];
let x = SimpleTriVec4::new(6, 2, 8, 3);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T, y: T, z: T, w: T, a: T) -> SimpleQuadVec5<T>

Constructs a SimpleQuadVec5 directly from components

Examples

let arr = [6, 2, 8, 3, 1];
let x = SimpleQuadVec5::new(6, 2, 8, 3, 1);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T, y: T, z: T, w: T, a: T, b: T) -> SimplePentVec6<T>

Constructs a SimplePentVec6 directly from components

Examples

let arr = [6, 2, 8, 3, 1, 8];
let x = SimplePentVec6::new(6, 2, 8, 3, 1, 8);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T) -> SimpleBiVec2<T>

Constructs a SimpleBiVec2 directly from components

Examples

let arr = [6];
let x = SimpleBiVec2::new(6);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T) -> SimpleTriVec3<T>

Constructs a SimpleTriVec3 directly from components

Examples

let arr = [6];
let x = SimpleTriVec3::new(6);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T) -> SimpleQuadVec4<T>

Constructs a SimpleQuadVec4 directly from components

Examples

let arr = [6];
let x = SimpleQuadVec4::new(6);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T) -> SimplePentVec5<T>

Constructs a SimplePentVec5 directly from components

Examples

let arr = [6];
let x = SimplePentVec5::new(6);

assert_eq!(x.as_slice(), &arr);

impl<T> SimpleBlade<T, Const<{_: usize}>, Const<{_: usize}>>

pub const fn new(x: T) -> SimpleHexVec6<T>

Constructs a SimpleHexVec6 directly from components

Examples

let arr = [6];
let x = SimpleHexVec6::new(6);

assert_eq!(x.as_slice(), &arr);

impl<T: AllocBlade<N, U0>, N: DimName> SimpleBlade<T, N, Const<{_: usize}>>

pub fn new(x: T) -> Self

Creates a new SimpleScalar directly from its component

use wedged::subspace::*;
use wedged::base::U1;

let x = 6.2831;
let s = SimpleScalar::<_,U1>::new(x);

assert_eq!(s.value, x);

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

pub fn new_psuedoscalar(x: T) -> Self

Creates a psuedoscalar directly from its component

use wedged::subspace::*;
use wedged::base::U3;

let x = 6.2831;
let s = SimpleBlade::<_,U3,U3>::new_psuedoscalar(x);

assert_eq!(s.value, x);
assert_eq!(s.grade(), 3);

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 as_mut_slice(&mut self) -> &mut [T]

Borrows the components of this value as a mutable slice

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

Creates an iterator over references of each component

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Creates an iterator over mutable 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 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: &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 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: &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<SimpleBlade<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: &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<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 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<'b, T1, T2, U, N: Dim, G: Dim> Add<&'b SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: Add<&'b T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> Add<&'b SimpleBlade<T2, N, G>> for &'a SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: RefAdd<'a, &'b T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T1, T2, U, N: Dim, G: Dim> Add<SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: Add<T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Add<SimpleBlade<T2, N, G>> for &'a SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: RefAdd<'a, T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T1, T2, N: Dim, G: Dim> AddAssign<&'a SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G> + AddAssign<&'a T2>,
    T2: AllocSimpleBlade<N, G>, 

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

Performs the += operation.

impl<T1, T2, N: Dim, G: Dim> AddAssign<SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G> + AddAssign<T2>,
    T2: AllocSimpleBlade<N, G>, 

fn add_assign(&mut self, rhs: SimpleBlade<T2, N, G>)

Performs the += operation.

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> AsMut<[T]> for SimpleBlade<T, N, G>

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

Performs the conversion.

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> AsMut<Blade<T, N, G>> for SimpleBlade<T, N, G>

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

Performs the conversion.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> AsRef<[T]> for SimpleBlade<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 SimpleBlade<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 SimpleBlade<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> BitXor<&'b SimpleBlade<T2, N, G2>> for SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimAdd<G2>,
    U: AllocBlade<N, DimSum<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSum<G1, G2>>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b, T1, T2, U, N: Dim, G1: Dim, G2: Dim> BitXor<&'b SimpleBlade<T2, N, G2>> for &'a SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimAdd<G2>,
    U: AllocBlade<N, DimSum<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSum<G1, G2>>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T1, T2, U, N: Dim, G1: Dim, G2: Dim> BitXor<SimpleBlade<T2, N, G2>> for SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimAdd<G2>,
    U: AllocBlade<N, DimSum<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSum<G1, G2>>

The resulting type after applying the ^ operator.

fn bitxor(
    self,
    rhs: SimpleBlade<T2, N, G2>
) -> SimpleBlade<U, N, DimSum<G1, G2>>

Performs the ^ operation.

impl<'a, T1, T2, U, N: Dim, G1: Dim, G2: Dim> BitXor<SimpleBlade<T2, N, G2>> for &'a SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimAdd<G2>,
    U: AllocBlade<N, DimSum<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSum<G1, G2>>

The resulting type after applying the ^ operator.

fn bitxor(
    self,
    rhs: SimpleBlade<T2, N, G2>
) -> SimpleBlade<U, N, DimSum<G1, G2>>

Performs the ^ operation.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Borrow<[T]> for SimpleBlade<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 SimpleBlade<T, N, G>

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

Immutably borrows from an owned value.

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> BorrowMut<[T]> for SimpleBlade<T, N, G>

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

Mutably borrows from an owned value.

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> BorrowMut<Blade<T, N, G>> for SimpleBlade<T, N, G>

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

Mutably borrows from an owned value.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Clone for SimpleBlade<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 SimpleBlade<T, N, G>

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

Formats the value using the given formatter.

impl<T: AllocSimpleBlade<N, G> + Default, N: DimName, G: DimName> Default for SimpleBlade<T, N, G>

fn default() -> SimpleBlade<T, N, G>

Returns the “default value” for a type.

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

type Target = Blade<T, N, G>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> DerefMut for SimpleBlade<T, N, G>

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

Mutably dereferences the value.

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

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

Formats the value using the given formatter.

impl<T1, T2, U, N: Dim, G: Dim> Div<T2> for SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: Div<T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Div<T2> for &'a SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: RefDiv<'a, T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T: AllocBlade<N, G> + DivAssign<&'a T>, N: Dim, G: Dim> DivAssign<&'a T> for SimpleBlade<T, N, G>

fn div_assign(&mut self, t: &'a T)

Performs the /= operation.

impl<T: AllocBlade<N, G> + DivAssign<T> + Clone, N: Dim, G: Dim> DivAssign<T> for SimpleBlade<T, N, G>

fn div_assign(&mut self, t: T)

Performs the /= operation.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> From<Blade<T, N, G>> for SimpleBlade<T, N, G>

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

Performs the conversion.

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

fn from(x: SimpleBlade<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: AllocSimpleBlade<N, G>, N: DimName, G: DimName> FromIterator<T> for SimpleBlade<T, N, G>

fn from_iter<I: IntoIterator<Item = T>>(i: I) -> SimpleBlade<T, N, G>

Creates a value from an iterator.

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Hash for SimpleBlade<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 SimpleBlade<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: AllocSimpleBlade<N, G>, N: Dim, G: Dim> IndexMut<usize> for SimpleBlade<T, N, G>

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

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

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> IntoIterator for SimpleBlade<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 SimpleBlade<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<'a, T: AllocSimpleBlade<N, G>, N: Dim, G: Dim> IntoIterator for &'a mut SimpleBlade<T, N, G>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T, N: Dim, G: Dim> Inv for SimpleBlade<T, N, G> where
    T: AllocBlade<N, G>,
    T: Neg<Output = T> + Clone + RefComplexField, 

type Output = SimpleBlade<T, N, G>

The result after applying the operator.

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

Returns the multiplicative inverse of self.

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

type Output = SimpleBlade<T, N, G>

The result after applying the operator.

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

Returns the multiplicative inverse of self.

impl<T1, T2, U, N: Dim, G: Dim> InvScale<T2> for SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: Div<T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

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

impl<'a, T1, T2, U, N: Dim, G: Dim> InvScale<T2> for &'a SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: RefDiv<'a, T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

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

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

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

Formats the value using the given formatter.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<f32, N, G>> for f32 where
    f32: AllocBlade<N, G>, 

type Output = SimpleBlade<f32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<f32, N, G>) -> SimpleBlade<f32, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<f32, N, G>> for &'a f32 where
    f32: AllocBlade<N, G>, 

type Output = SimpleBlade<f32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<f32, N, G>) -> SimpleBlade<f32, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<f64, N, G>> for f64 where
    f64: AllocBlade<N, G>, 

type Output = SimpleBlade<f64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<f64, N, G>) -> SimpleBlade<f64, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<f64, N, G>> for &'a f64 where
    f64: AllocBlade<N, G>, 

type Output = SimpleBlade<f64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<f64, N, G>) -> SimpleBlade<f64, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i128, N, G>> for i128 where
    i128: AllocBlade<N, G>, 

type Output = SimpleBlade<i128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i128, N, G>) -> SimpleBlade<i128, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i128, N, G>> for &'a i128 where
    i128: AllocBlade<N, G>, 

type Output = SimpleBlade<i128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i128, N, G>) -> SimpleBlade<i128, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i16, N, G>> for i16 where
    i16: AllocBlade<N, G>, 

type Output = SimpleBlade<i16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i16, N, G>) -> SimpleBlade<i16, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i16, N, G>> for &'a i16 where
    i16: AllocBlade<N, G>, 

type Output = SimpleBlade<i16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i16, N, G>) -> SimpleBlade<i16, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i32, N, G>> for i32 where
    i32: AllocBlade<N, G>, 

type Output = SimpleBlade<i32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i32, N, G>) -> SimpleBlade<i32, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i32, N, G>> for &'a i32 where
    i32: AllocBlade<N, G>, 

type Output = SimpleBlade<i32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i32, N, G>) -> SimpleBlade<i32, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i64, N, G>> for i64 where
    i64: AllocBlade<N, G>, 

type Output = SimpleBlade<i64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i64, N, G>) -> SimpleBlade<i64, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i64, N, G>> for &'a i64 where
    i64: AllocBlade<N, G>, 

type Output = SimpleBlade<i64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i64, N, G>) -> SimpleBlade<i64, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i8, N, G>> for i8 where
    i8: AllocBlade<N, G>, 

type Output = SimpleBlade<i8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i8, N, G>) -> SimpleBlade<i8, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<i8, N, G>> for &'a i8 where
    i8: AllocBlade<N, G>, 

type Output = SimpleBlade<i8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<i8, N, G>) -> SimpleBlade<i8, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<isize, N, G>> for isize where
    isize: AllocBlade<N, G>, 

type Output = SimpleBlade<isize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<isize, N, G>) -> SimpleBlade<isize, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<isize, N, G>> for &'a isize where
    isize: AllocBlade<N, G>, 

type Output = SimpleBlade<isize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<isize, N, G>) -> SimpleBlade<isize, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u128, N, G>> for u128 where
    u128: AllocBlade<N, G>, 

type Output = SimpleBlade<u128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u128, N, G>) -> SimpleBlade<u128, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u128, N, G>> for &'a u128 where
    u128: AllocBlade<N, G>, 

type Output = SimpleBlade<u128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u128, N, G>) -> SimpleBlade<u128, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u16, N, G>> for u16 where
    u16: AllocBlade<N, G>, 

type Output = SimpleBlade<u16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u16, N, G>) -> SimpleBlade<u16, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u16, N, G>> for &'a u16 where
    u16: AllocBlade<N, G>, 

type Output = SimpleBlade<u16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u16, N, G>) -> SimpleBlade<u16, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u32, N, G>> for u32 where
    u32: AllocBlade<N, G>, 

type Output = SimpleBlade<u32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u32, N, G>) -> SimpleBlade<u32, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u32, N, G>> for &'a u32 where
    u32: AllocBlade<N, G>, 

type Output = SimpleBlade<u32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u32, N, G>) -> SimpleBlade<u32, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u64, N, G>> for u64 where
    u64: AllocBlade<N, G>, 

type Output = SimpleBlade<u64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u64, N, G>) -> SimpleBlade<u64, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u64, N, G>> for &'a u64 where
    u64: AllocBlade<N, G>, 

type Output = SimpleBlade<u64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u64, N, G>) -> SimpleBlade<u64, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u8, N, G>> for u8 where
    u8: AllocBlade<N, G>, 

type Output = SimpleBlade<u8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u8, N, G>) -> SimpleBlade<u8, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<u8, N, G>> for &'a u8 where
    u8: AllocBlade<N, G>, 

type Output = SimpleBlade<u8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<u8, N, G>) -> SimpleBlade<u8, N, G>

Performs the * operation.

impl<'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<usize, N, G>> for usize where
    usize: AllocBlade<N, G>, 

type Output = SimpleBlade<usize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<usize, N, G>) -> SimpleBlade<usize, N, G>

Performs the * operation.

impl<'a, 'b, N: Dim, G: Dim> Mul<&'b SimpleBlade<usize, N, G>> for &'a usize where
    usize: AllocBlade<N, G>, 

type Output = SimpleBlade<usize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b SimpleBlade<usize, N, G>) -> SimpleBlade<usize, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<f32, N, G>> for f32 where
    f32: AllocBlade<N, G>, 

type Output = SimpleBlade<f32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<f32, N, G>) -> SimpleBlade<f32, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<f32, N, G>> for &'a f32 where
    f32: AllocBlade<N, G>, 

type Output = SimpleBlade<f32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<f32, N, G>) -> SimpleBlade<f32, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<f64, N, G>> for f64 where
    f64: AllocBlade<N, G>, 

type Output = SimpleBlade<f64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<f64, N, G>) -> SimpleBlade<f64, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<f64, N, G>> for &'a f64 where
    f64: AllocBlade<N, G>, 

type Output = SimpleBlade<f64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<f64, N, G>) -> SimpleBlade<f64, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<i128, N, G>> for i128 where
    i128: AllocBlade<N, G>, 

type Output = SimpleBlade<i128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i128, N, G>) -> SimpleBlade<i128, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<i128, N, G>> for &'a i128 where
    i128: AllocBlade<N, G>, 

type Output = SimpleBlade<i128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i128, N, G>) -> SimpleBlade<i128, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<i16, N, G>> for i16 where
    i16: AllocBlade<N, G>, 

type Output = SimpleBlade<i16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i16, N, G>) -> SimpleBlade<i16, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<i16, N, G>> for &'a i16 where
    i16: AllocBlade<N, G>, 

type Output = SimpleBlade<i16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i16, N, G>) -> SimpleBlade<i16, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<i32, N, G>> for i32 where
    i32: AllocBlade<N, G>, 

type Output = SimpleBlade<i32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i32, N, G>) -> SimpleBlade<i32, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<i32, N, G>> for &'a i32 where
    i32: AllocBlade<N, G>, 

type Output = SimpleBlade<i32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i32, N, G>) -> SimpleBlade<i32, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<i64, N, G>> for i64 where
    i64: AllocBlade<N, G>, 

type Output = SimpleBlade<i64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i64, N, G>) -> SimpleBlade<i64, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<i64, N, G>> for &'a i64 where
    i64: AllocBlade<N, G>, 

type Output = SimpleBlade<i64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i64, N, G>) -> SimpleBlade<i64, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<i8, N, G>> for i8 where
    i8: AllocBlade<N, G>, 

type Output = SimpleBlade<i8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i8, N, G>) -> SimpleBlade<i8, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<i8, N, G>> for &'a i8 where
    i8: AllocBlade<N, G>, 

type Output = SimpleBlade<i8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<i8, N, G>) -> SimpleBlade<i8, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<isize, N, G>> for isize where
    isize: AllocBlade<N, G>, 

type Output = SimpleBlade<isize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<isize, N, G>) -> SimpleBlade<isize, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<isize, N, G>> for &'a isize where
    isize: AllocBlade<N, G>, 

type Output = SimpleBlade<isize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<isize, N, G>) -> SimpleBlade<isize, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<u128, N, G>> for u128 where
    u128: AllocBlade<N, G>, 

type Output = SimpleBlade<u128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u128, N, G>) -> SimpleBlade<u128, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<u128, N, G>> for &'a u128 where
    u128: AllocBlade<N, G>, 

type Output = SimpleBlade<u128, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u128, N, G>) -> SimpleBlade<u128, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<u16, N, G>> for u16 where
    u16: AllocBlade<N, G>, 

type Output = SimpleBlade<u16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u16, N, G>) -> SimpleBlade<u16, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<u16, N, G>> for &'a u16 where
    u16: AllocBlade<N, G>, 

type Output = SimpleBlade<u16, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u16, N, G>) -> SimpleBlade<u16, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<u32, N, G>> for u32 where
    u32: AllocBlade<N, G>, 

type Output = SimpleBlade<u32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u32, N, G>) -> SimpleBlade<u32, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<u32, N, G>> for &'a u32 where
    u32: AllocBlade<N, G>, 

type Output = SimpleBlade<u32, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u32, N, G>) -> SimpleBlade<u32, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<u64, N, G>> for u64 where
    u64: AllocBlade<N, G>, 

type Output = SimpleBlade<u64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u64, N, G>) -> SimpleBlade<u64, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<u64, N, G>> for &'a u64 where
    u64: AllocBlade<N, G>, 

type Output = SimpleBlade<u64, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u64, N, G>) -> SimpleBlade<u64, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<u8, N, G>> for u8 where
    u8: AllocBlade<N, G>, 

type Output = SimpleBlade<u8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u8, N, G>) -> SimpleBlade<u8, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<u8, N, G>> for &'a u8 where
    u8: AllocBlade<N, G>, 

type Output = SimpleBlade<u8, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<u8, N, G>) -> SimpleBlade<u8, N, G>

Performs the * operation.

impl<N: Dim, G: Dim> Mul<SimpleBlade<usize, N, G>> for usize where
    usize: AllocBlade<N, G>, 

type Output = SimpleBlade<usize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<usize, N, G>) -> SimpleBlade<usize, N, G>

Performs the * operation.

impl<'a, N: Dim, G: Dim> Mul<SimpleBlade<usize, N, G>> for &'a usize where
    usize: AllocBlade<N, G>, 

type Output = SimpleBlade<usize, N, G>

The resulting type after applying the * operator.

fn mul(self, rhs: SimpleBlade<usize, N, G>) -> SimpleBlade<usize, N, G>

Performs the * operation.

impl<T1, T2, U, N: Dim, G: Dim> Mul<T2> for SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: Mul<T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Mul<T2> for &'a SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: RefMul<'a, T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: AllocBlade<N, G> + MulAssign<&'a T>, N: Dim, G: Dim> MulAssign<&'a T> for SimpleBlade<T, N, G>

fn mul_assign(&mut self, t: &'a T)

Performs the *= operation.

impl<T: AllocBlade<N, G> + MulAssign<T> + Clone, N: Dim, G: Dim> MulAssign<T> for SimpleBlade<T, N, G>

fn mul_assign(&mut self, t: T)

Performs the *= operation.

impl<T, U, N: Dim, G: Dim> Neg for SimpleBlade<T, N, G> where
    T: AllocBlade<N, G>,
    U: AllocBlade<N, G>,
    T: Neg<Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the - operator.

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

Performs the unary - operation.

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

type Output = SimpleBlade<U, N, G>

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl<'a, T: AllocBlade<N, G> + Octal, N: Dim, G: Dim> Octal for SimpleBlade<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 SimpleBlade<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 Blade<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<SimpleBlade<T2, N2, G2>> for SimpleBlade<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<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 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<T, N: Dim, G1: Dim, G2: Dim> Project<Blade<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 = 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 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: SimpleBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Project<SimpleBlade<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: SimpleBlade<T, N, G2>) -> SimpleBlade<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 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> Reject<Blade<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 = 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 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: SimpleBlade<T, N, G2>) -> SimpleBlade<T, N, G2>

impl<T, N: Dim, G1: Dim, G2: Dim> Reject<SimpleBlade<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: SimpleBlade<T, N, G2>) -> SimpleBlade<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 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<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> RelativeEq<Blade<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: &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 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: &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<SimpleBlade<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: &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<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 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<'b, T1, T2, U, N: Dim, G1: Dim, G2: Dim> Rem<&'b SimpleBlade<T2, N, G2>> for SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimSymSub<G2>,
    U: AllocBlade<N, DimSymDiff<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSymDiff<G1, G2>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a, 'b, T1, T2, U, N: Dim, G1: Dim, G2: Dim> Rem<&'b SimpleBlade<T2, N, G2>> for &'a SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimSymSub<G2>,
    U: AllocBlade<N, DimSymDiff<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSymDiff<G1, G2>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T1, T2, U, N: Dim, G1: Dim, G2: Dim> Rem<SimpleBlade<T2, N, G2>> for SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimSymSub<G2>,
    U: AllocBlade<N, DimSymDiff<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSymDiff<G1, G2>>

The resulting type after applying the % operator.

fn rem(
    self,
    rhs: SimpleBlade<T2, N, G2>
) -> SimpleBlade<U, N, DimSymDiff<G1, G2>>

Performs the % operation.

impl<'a, T1, T2, U, N: Dim, G1: Dim, G2: Dim> Rem<SimpleBlade<T2, N, G2>> for &'a SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    G1: DimSymSub<G2>,
    U: AllocBlade<N, DimSymDiff<G1, G2>> + AddGroup, 

type Output = SimpleBlade<U, N, DimSymDiff<G1, G2>>

The resulting type after applying the % operator.

fn rem(
    self,
    rhs: SimpleBlade<T2, N, G2>
) -> SimpleBlade<U, N, DimSymDiff<G1, G2>>

Performs the % operation.

impl<T1, T2, U, N: Dim, G: Dim> Scale<T2> for SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: Mul<T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

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

impl<'a, T1, T2, U, N: Dim, G: Dim> Scale<T2> for &'a SimpleBlade<T1, N, G> where
    T1: AllocBlade<N, G>,
    T2: Clone,
    U: AllocBlade<N, G>,
    T1: RefMul<'a, T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

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

impl<'b, T1, T2, U, N: Dim, G: Dim> Sub<&'b SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: Sub<&'b T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T1, T2, U, N: Dim, G: Dim> Sub<&'b SimpleBlade<T2, N, G>> for &'a SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: RefSub<'a, &'b T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T1, T2, U, N: Dim, G: Dim> Sub<SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: Sub<T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T1, T2, U, N: Dim, G: Dim> Sub<SimpleBlade<T2, N, G>> for &'a SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G>,
    T2: AllocSimpleBlade<N, G>,
    U: AllocSimpleBlade<N, G>,
    T1: RefSub<'a, T2, Output = U>, 

type Output = SimpleBlade<U, N, G>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T1, T2, N: Dim, G: Dim> SubAssign<&'a SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G> + SubAssign<&'a T2>,
    T2: AllocSimpleBlade<N, G>, 

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

Performs the -= operation.

impl<T1, T2, N: Dim, G: Dim> SubAssign<SimpleBlade<T2, N, G>> for SimpleBlade<T1, N, G> where
    T1: AllocSimpleBlade<N, G> + SubAssign<T2>,
    T2: AllocSimpleBlade<N, G>, 

fn sub_assign(&mut self, rhs: SimpleBlade<T2, N, G>)

Performs the -= operation.

impl<'a, T, U, N: Dim, G: Dim> Sum<&'a SimpleBlade<T, N, G>> for SimpleBlade<U, N, G> where
    T: AllocBlade<N, G>,
    U: AllocBlade<N, G>,
    SimpleBlade<U, N, G>: Add<&'a SimpleBlade<T, N, G>, Output = SimpleBlade<U, N, G>> + Zero, 

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

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, U, N: Dim, G: Dim> Sum<SimpleBlade<T, N, G>> for SimpleBlade<U, N, G> where
    T: AllocBlade<N, G>,
    U: AllocBlade<N, G>,
    SimpleBlade<U, N, G>: Add<SimpleBlade<T, N, G>, Output = SimpleBlade<U, N, G>> + Zero, 

fn sum<I>(i: I) -> SimpleBlade<U, N, G> where
    I: Iterator<Item = SimpleBlade<T, N, G>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T1, T2, N1: Dim, G1: Dim, N2: Dim, G2: Dim> UlpsEq<Blade<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: &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 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: &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<SimpleBlade<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: &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<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 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<'a, T: AllocBlade<N, G> + UpperExp, N: Dim, G: Dim> UpperExp for SimpleBlade<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 SimpleBlade<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 SimpleBlade<T1, N, G1> where
    T1: AllocBlade<N, G1> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>, 

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

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

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

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

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

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

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

type Output = Odd<U, N>

fn versor_mul(self, rhs: &'b Odd<T2, N>) -> Odd<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, 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, G2: Dim> VersorMul<&'b SimpleBlade<T2, N, G2>> for Even<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<&'b SimpleBlade<T2, N, G2>> for &'a Even<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<&'b SimpleBlade<T2, N, G2>> for Odd<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<&'b SimpleBlade<T2, N, G2>> for &'a Odd<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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

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

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

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

type Output = SimpleBlade<U, N, G2>

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

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

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

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

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

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

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

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

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

type Output = Odd<U, N>

fn versor_mul(self, rhs: Odd<T2, N>) -> Odd<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, 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, G2: Dim> VersorMul<SimpleBlade<T2, N, G2>> for Even<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<SimpleBlade<T2, N, G2>> for &'a Even<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<SimpleBlade<T2, N, G2>> for Odd<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<SimpleBlade<T2, N, G2>> for &'a Odd<T1, N> where
    T1: AllocOdd<N> + AllRefMul<T2, AllOutput = U> + AllRefMul<T1, AllOutput = U>,
    T2: AllocBlade<N, G2>,
    U: AllocBlade<N, G2> + for<'c> Mul<&'c T1, Output = U> + AddGroup,
    U: for<'c> Div<&'c U, Output = U>,
    N: ToTypenum,
    AsTypenum<N>: IsLessOrEqual<U3, Output = True>, 

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, G2: Dim> VersorMul<SimpleBlade<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 = SimpleBlade<U, N, G2>

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

impl<'a, T1, T2, U, N: Dim, G2: Dim> VersorMul<SimpleBlade<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 = SimpleBlade<U, N, G2>

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

impl<T1, T2, U, N: Dim, G2: Dim> VersorMul<SimpleBlade<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 = SimpleBlade<U, N, G2>

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

impl<'a, T1, T2, U, N: Dim, G2: Dim> VersorMul<SimpleBlade<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 = SimpleBlade<U, N, G2>

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

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

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

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

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

type Output = SimpleBlade<U, N, G2>

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

impl<T: AllocSimpleBlade<N, G> + Zero, N: DimName, G: DimName> Zero for SimpleBlade<T, N, G>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

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

impl<T: AllocBlade<N, G>, N: Dim, G: Dim> Copy for SimpleBlade<T, N, G> where
    T: Copy,
    Blade<T, N, G>: Copy, 

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