Struct wedged::subspace::Rotor

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

Represents a rotation in N dimensions

Implementations

impl<T: AllocEven<N>, N: Dim> Rotor<T, N>

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

Unrwaps self into its internal algebraic type

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

Unrwaps self into a reference to its internal algebraic type

pub fn from_inner_unchecked(b: Even<T, N>) -> 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: AllocEven<N> + Neg<Output = T>, N: Dim> Rotor<T, N>

pub fn reverse(self) -> Self

Reverses the order of the vectors in each basis blade

pub fn involute(self) -> Self

Negates self of each component with an odd grade

pub fn inverse(self) -> Self

The multiplicative inverse of this element

impl<T: AllocEven<N>, N: Dim> Rotor<T, N>

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

impl<T: AllocEven<Dynamic>> Rotor<T, Dynamic>

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

impl<T: AllocEven<N> + RefUnitRing, N: Dim> Rotor<T, N>

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

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

impl<T: AllocEven<N>, N: Dim> Rotor<T, N>

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

Rotates the given input by self

impl<T: AllocEven<N> + RefRealField, N: Dim> Rotor<T, N>

pub fn from_scaled_plane(plane: SimpleBiVecN<T, N>) -> Self where
    T: AllocBlade<N, U2>, 

Creates a new Rotor rotating in the plane of the input and by the angle given by its norm

pub fn from_plane_angle(plane: UnitBiVecN<T, N>, angle: T) -> Self where
    T: AllocBlade<N, U2>, 

Creates a new Rotor that rotates in the given plane by the given angle

pub fn log(self) -> BiVecN<T, N> where
    T: AllocBlade<N, U2>, 

Computes a bivector whos exponential is self

The result should be a bivector that is the sum of floor(N/2) simple bivectors with directions and magnitudes corresponding to the planes and angles of the simple rotations making up this Rotor.

Uniqueness

As with other non-real logarithms, the result of this function is not unique:

• As with complex logarithms, an angle of 2π can always be added in the direction of the output to get a result with the same exponential.
• When self == -1 and N >= 3, there are infinitely many planes in which the rotation could have taken place, so an arbitrary choice is picked.
• For isoclinic rotations (ie double rotations where both rotations have the same angle), the choice of rotation planes is also not unique, so again, an arbitrary choice is picked.

pub fn powf(self, t: T) -> Self where
    T: AllocBlade<N, U2>, 

Raises this rotor to the power of a real number

Geometrically, this scales the angles of rotation of this rotor by t.

More concretely, this is calulated as x^t == exp(t*log(x)). As such, whenever log() makes an arbitrary choice for the rotation plane, this function does as well.

pub fn slerp(self, other: Self, t: T) -> Self where
    T: AllocBlade<N, U2>, 

Smoothly interpolates the rotations of self and other

Concretely, this is computed as (other/self)^t * self

impl<T: AllocEven<U2> + RefRealField> Rotor<T, Const<{_: usize}>>

pub fn from_angle(angle: T) -> Self

Creates a 2D rotation from an angle

pub fn get_angle(&self) -> T where
    T: RefRealField, 

Returns the angle of this Rotor’s rotation

impl<T: AllocEven<U2> + RefRealField> Rotor<T, Const<{_: usize}>>

pub fn from_scaled_axis(scaled_axis: Vec3<T>) -> Self

Creates a 3D rotation about the given vector axis where the angle is the norm of the vector

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

Creates a 3D rotation about the given axis with the given angle

pub fn get_plane_angle(self) -> Option<(UnitBiVec3<T>, T)>

Returns the plane and angle of rotation or None if the angle is 0

pub fn get_scaled_plane(self) -> SimpleBiVec3<T>

Returns the plane of rotation scaled by the angle of rotation

pub fn get_axis_angle(self) -> Option<(UnitVec3<T>, T)>

Returns the axis and angle of rotation or None if the angle is 0

pub fn get_scaled_axis(self) -> Vec3<T>

Returns the axis of rotation scaled by the angle of rotation

impl<T: AllocEven<U2> + RefRealField> Rotor<T, Const<{_: usize}>>

pub fn get_plane_angles(
    self
) -> (Option<(UnitBiVec4<T>, T)>, Option<(UnitBiVec4<T>, T)>)

Returns both planes and both angles of rotation or None for either if they are 0

pub fn get_scaled_planes(self) -> (SimpleBiVec4<T>, SimpleBiVec4<T>)

Returns both planes of rotation scaled by their angles of rotation

impl<T: AllocEven<N> + AllocBlade<N, U1> + RefRealField, N: Dim> Rotor<T, N>

pub fn rot_between_unit(v1: UnitVecN<T, N>, v2: UnitVecN<T, N>) -> Self where
    T: AllocBlade<N, U1>, 

pub fn rot_between_simple(v1: SimpleVecN<T, N>, v2: SimpleVecN<T, N>) -> Self where
    T: AllocBlade<N, U1>, 

pub fn rot_between(v1: VecN<T, N>, v2: VecN<T, N>) -> Self where
    T: AllocBlade<N, U1>, 

impl<T: AllocEven<N1> + Zero, N1: Dim> Rotor<T, N1>

pub fn cast_dim_generic_unchecked<N2: Dim>(self, n: N2) -> Rotor<T, N2> where
    T: AllocEven<N2>, 

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

pub fn cast_dim_dyn_unchecked(self, n: usize) -> Rotor<T, Dynamic> where
    T: AllocEven<Dynamic>, 

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

pub fn cast_dim_unchecked<N2: DimName>(self) -> Rotor<T, N2> where
    T: AllocEven<N2>, 

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

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

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

impl<T: AllocEven<N>, N: Dim> Rotor<T, N>

pub fn into_even(self) -> Even<T, N>

pub fn into_versor(self) -> Versor<T, N> where
    T: AllocVersor<N>, 

Methods from Deref<Target = Even<T, N>>

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 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 elements(&self) -> usize

The number of coordinates this value has

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

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

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

Examples

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

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

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

Borrows the components of this value as a slice

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

Creates an iterator over references of each component

pub fn even(&self) -> bool

Always true, but useful for macros

pub fn odd(&self) -> bool

Always false, but useful for macros

pub fn shape_eq<T2: AllocEven<N2>, N2: Dim>(&self, rhs: &Even<T2, N2>) -> bool

Determines if the dimension of two Evens 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.

Trait Implementations

impl<T1, T2, N1: Dim, N2: Dim> AbsDiffEq<Even<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + AbsDiffEq<T2>,
    T2: AllocEven<N2>,
    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: &Even<T2, N2>, 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: &Even<T2, N2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T1, T2, N1: Dim, N2: Dim> AbsDiffEq<Rotor<T2, N2>> for Even<T1, N1> where
    T1: AllocEven<N1> + AbsDiffEq<T2>,
    T2: AllocEven<N2>,
    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: &Rotor<T2, N2>, 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: &Rotor<T2, N2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T1, T2, N1: Dim, N2: Dim> AbsDiffEq<Rotor<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + AbsDiffEq<T2>,
    T2: AllocEven<N2>,
    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: &Rotor<T2, N2>, 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: &Rotor<T2, N2>, epsilon: T1::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: AllocEven<N>, N: Dim> AsRef<[T]> for Rotor<T, N>

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

Performs the conversion.

impl<T: AllocEven<N>, N: Dim> AsRef<Even<T, N>> for Rotor<T, N>

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

Performs the conversion.

impl<'a, T: AllocEven<N> + Binary, N: Dim> Binary for Rotor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocEven<N>, N: Dim> Borrow<[T]> for Rotor<T, N>

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

Immutably borrows from an owned value.

impl<T: AllocEven<N>, N: Dim> Borrow<Even<T, N>> for Rotor<T, N>

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

Immutably borrows from an owned value.

impl<T: AllocEven<N>, N: Dim> Clone for Rotor<T, N> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: AllocEven<N> + Debug, N: Dim> Debug for Rotor<T, N>

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

Formats the value using the given formatter.

impl<T: AllocEven<N>, N: Dim> Deref for Rotor<T, N>

type Target = Even<T, N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T: AllocEven<N> + Display, N: Dim> Display for Rotor<T, N>

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

Formats the value using the given formatter.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Rotor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Rotor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Rotor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Rotor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Reflector<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Versor<U, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<'a, T: AllocEven<N>, N: Dim> From<&'a Rotor<T, N>> for &'a Even<T, N>

fn from(x: &'a Rotor<T, N>) -> &'a Even<T, N>

Performs the conversion.

impl<'a, T: AllocEven<N>, N: Dim> From<&'a mut Rotor<T, N>> for &'a mut Even<T, N>

fn from(x: &'a mut Rotor<T, N>) -> &'a mut Even<T, N>

Performs the conversion.

impl<T: AllocEven<N>, N: Dim> From<Rotor<T, N>> for Even<T, N>

fn from(x: Rotor<T, N>) -> Even<T, N>

Performs the conversion.

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

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

Performs the conversion.

impl<T: AllocEven<N>, N: Dim> Hash for Rotor<T, N> where
    T: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T: AllocEven<N>, N: Dim> Index<usize> for Rotor<T, N>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: AllocEven<N>, N: Dim> IntoIterator for Rotor<T, N>

type Item = T

The type of the elements being iterated over.

type IntoIter = <Even<T, N> 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: AllocEven<N>, N: Dim> IntoIterator for &'a Rotor<T, N>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, N: Dim> Inv for Rotor<T, N> where
    T: AllocEven<N>,
    T: Neg<Output = T>, 

type Output = Rotor<T, N>

The result after applying the operator.

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

Returns the multiplicative inverse of self.

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

type Output = Rotor<T, N>

The result after applying the operator.

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

Returns the multiplicative inverse of self.

impl<'a, T: AllocEven<N> + LowerExp, N: Dim> LowerExp for Rotor<T, N>

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

Formats the value using the given formatter.

impl<'a, T: AllocEven<N> + LowerHex, N: Dim> LowerHex for Rotor<T, N>

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

Formats the value using the given formatter.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Rotor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Rotor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Rotor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Rotor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Reflector<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Versor<U, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

impl<T, U, N: Dim> Neg for Rotor<T, N> where
    T: AllocEven<N>,
    U: AllocEven<N>,
    T: Neg<Output = U>, 

type Output = Rotor<U, N>

The resulting type after applying the - operator.

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

Performs the unary - operation.

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

type Output = Rotor<U, N>

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl<'a, T: AllocEven<N> + Octal, N: Dim> Octal for Rotor<T, N>

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

Formats the value using the given formatter.

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

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

impl<T1, T2, N1: Dim, N2: Dim> PartialEq<Even<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + PartialEq<T2>,
    T2: AllocEven<N2>, 

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

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

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

This method tests for !=.

impl<T1, T2, N1: Dim, N2: Dim> PartialEq<Rotor<T2, N2>> for Even<T1, N1> where
    T1: AllocEven<N1> + PartialEq<T2>,
    T2: AllocEven<N2>, 

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

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

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

This method tests for !=.

impl<T1, T2, N1: Dim, N2: Dim> PartialEq<Rotor<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + PartialEq<T2>,
    T2: AllocEven<N2>, 

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

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

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

This method tests for !=.

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

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

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

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

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

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

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

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

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

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

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

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

impl<T1, T2, N1: Dim, N2: Dim> RelativeEq<Even<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + RelativeEq<T2>,
    T2: AllocEven<N2>,
    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: &Even<T2, N2>,
    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: &Even<T2, N2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, N2: Dim> RelativeEq<Rotor<T2, N2>> for Even<T1, N1> where
    T1: AllocEven<N1> + RelativeEq<T2>,
    T2: AllocEven<N2>,
    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: &Rotor<T2, N2>,
    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: &Rotor<T2, N2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, N2: Dim> RelativeEq<Rotor<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + RelativeEq<T2>,
    T2: AllocEven<N2>,
    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: &Rotor<T2, N2>,
    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: &Rotor<T2, N2>,
    epsilon: T1::Epsilon,
    max_relative: T1::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T1, T2, N1: Dim, N2: Dim> UlpsEq<Even<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + UlpsEq<T2>,
    T2: AllocEven<N2>,
    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: &Even<T2, N2>,
    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: &Even<T2, N2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T1, T2, N1: Dim, N2: Dim> UlpsEq<Rotor<T2, N2>> for Even<T1, N1> where
    T1: AllocEven<N1> + UlpsEq<T2>,
    T2: AllocEven<N2>,
    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: &Rotor<T2, N2>,
    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: &Rotor<T2, N2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T1, T2, N1: Dim, N2: Dim> UlpsEq<Rotor<T2, N2>> for Rotor<T1, N1> where
    T1: AllocEven<N1> + UlpsEq<T2>,
    T2: AllocEven<N2>,
    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: &Rotor<T2, N2>,
    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: &Rotor<T2, N2>,
    epsilon: T1::Epsilon,
    max_ulps: u32
) -> bool

The inverse of UlpsEq::ulps_eq.

impl<'a, T: AllocEven<N> + UpperExp, N: Dim> UpperExp for Rotor<T, N>

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

Formats the value using the given formatter.

impl<'a, T: AllocEven<N> + UpperHex, N: Dim> UpperHex for Rotor<T, N>

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

Formats the value using the given formatter.

impl<'b, T1, T2, U, N: Dim, G2: Dim> VersorMul<&'b Blade<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 = 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, G2: Dim> VersorMul<&'b Blade<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 = 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> VersorMul<&'b Even<T2, N>> for Rotor<T1, N> where
    T1: AllocEven<N> + AllRefMul<T2, AllOutput = U>,
    T2: AllocEven<N>,
    U: AllocEven<N> + for<'c> Mul<&'c T1, Output = U> + AddGroup, 

type Output = Even<U, N>

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

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

type Output = Even<U, N>

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

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

type Output = Multivector<U, N>

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

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

type Output = Multivector<U, N>

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

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

type Output = Odd<U, N>

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

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

type Output = Odd<U, N>

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

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

type Output = Reflector<U, N>

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

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

type Output = Reflector<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = Versor<U, N>

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

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

type Output = Versor<U, N>

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

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

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

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

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

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

type Output = Even<U, N>

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

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

type Output = Even<U, N>

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

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

type Output = Multivector<U, N>

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

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

type Output = Multivector<U, N>

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

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

type Output = Odd<U, N>

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

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

type Output = Odd<U, N>

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

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

type Output = Reflector<U, N>

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

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

type Output = Reflector<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = Rotor<U, N>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = UnitBlade<U, N, G2>

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

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

type Output = Versor<U, N>

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

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

type Output = Versor<U, N>

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

impl<T: AllocEven<N>, N: Dim> Copy for Rotor<T, N> where
    T: Copy,
    Even<T, N>: Copy, 

impl<T: AllocEven<N> + Eq, N: Dim> Eq for Rotor<T, N>