Struct nalgebra::base::Unit

#[repr(transparent)]
pub struct Unit<T> { /* fields omitted */ }

A wrapper that ensures the underlying algebraic entity has a unit norm.

Use .as_ref() or .into_inner() to obtain the underlying value by-reference or by-move.

Methods

impl<N: ComplexField, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>>

pub fn slerp<S2: Storage<N, D>>(
    &self,
    rhs: &Unit<Vector<N, D, S2>>,
    t: N::RealField
) -> Unit<VectorN<N, D>> where
    DefaultAllocator: Allocator<N, D>, 

Computes the spherical linear interpolation between two unit vectors.

Examples:

let q1 = UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = UnitQuaternion::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);

let q = q1.slerp(&q2, 1.0 / 3.0);

assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

pub fn try_slerp<S2: Storage<N, D>>(
    &self,
    rhs: &Unit<Vector<N, D, S2>>,
    t: N::RealField,
    epsilon: N::RealField
) -> Option<Unit<VectorN<N, D>>> where
    DefaultAllocator: Allocator<N, D>, 

Computes the spherical linear interpolation between two unit vectors.

Returns None if the two vectors are almost collinear and with opposite direction (in this case, there is an infinity of possible results).

impl<T: NormedSpace> Unit<T>

pub fn new_normalize(value: T) -> Self

Normalize the given value and return it wrapped on a Unit structure.

pub fn try_new(value: T, min_norm: T::RealField) -> Option<Self>

Attempts to normalize the given value and return it wrapped on a Unit structure.

Returns None if the norm was smaller or equal to min_norm.

pub fn new_and_get(value: T) -> (Self, T::RealField)

Normalize the given value and return it wrapped on a Unit structure and its norm.

pub fn try_new_and_get(
    value: T,
    min_norm: T::RealField
) -> Option<(Self, T::RealField)>

Normalize the given value and return it wrapped on a Unit structure and its norm.

Returns None if the norm was smaller or equal to min_norm.

pub fn renormalize(&mut self) -> T::RealField

Normalizes this value again. This is useful when repeated computations might cause a drift in the norm because of float inaccuracies.

Returns the norm before re-normalization. See .renormalize_fast for a faster alternative that may be slightly less accurate if self drifted significantly from having a unit length.

pub fn renormalize_fast(&mut self)

Normalizes this value again using a first-order Taylor approximation. This is useful when repeated computations might cause a drift in the norm because of float inaccuracies.

impl<T> Unit<T>

pub fn new_unchecked(value: T) -> Self

Wraps the given value, assuming it is already normalized.

pub fn from_ref_unchecked<'a>(value: &'a T) -> &'a Self

Wraps the given reference, assuming it is already normalized.

pub fn into_inner(self) -> T

Retrieves the underlying value.

pub fn unwrap(self) -> T

Deprecated:

use .into_inner() instead

Retrieves the underlying value. Deprecated: use [Unit::into_inner] instead.

pub fn as_mut_unchecked(&mut self) -> &mut T

Returns a mutable reference to the underlying value. This is _unchecked because modifying the underlying value in such a way that it no longer has unit length may lead to unexpected results.

Trait Implementations

impl<T: Copy> Copy for Unit<T>

impl<T> AsRef<T> for Unit<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<T: Eq> Eq for Unit<T>

impl<T: Clone> Clone for Unit<T>

fn clone(&self) -> Unit<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PartialEq> PartialEq<Unit<T>> for Unit<T>

fn eq(&self, other: &Unit<T>) -> bool

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

fn ne(&self, other: &Unit<T>) -> bool

This method tests for !=.

impl<N: RealField> From<Unit<Quaternion<N>>> for Matrix4<N>

fn from(q: UnitQuaternion<N>) -> Self

Performs the conversion.

impl<N: RealField> From<Unit<Quaternion<N>>> for Rotation3<N>

fn from(q: UnitQuaternion<N>) -> Self

Performs the conversion.

impl<N: RealField> From<Unit<Quaternion<N>>> for Matrix3<N>

fn from(q: UnitQuaternion<N>) -> Self

Performs the conversion.

impl<N: RealField> From<Unit<Complex<N>>> for Rotation2<N>

fn from(q: UnitComplex<N>) -> Self

Performs the conversion.

impl<N: RealField> From<Unit<Complex<N>>> for Matrix3<N>

fn from(q: UnitComplex<N>) -> Matrix3<N>

Performs the conversion.

impl<N: RealField> From<Unit<Complex<N>>> for Matrix2<N>

fn from(q: UnitComplex<N>) -> Self

Performs the conversion.

impl<T> Deref for Unit<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Hash> Hash for Unit<T>

fn hash<__HT: Hasher>(&self, state: &mut __HT)

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: Debug> Debug for Unit<T>

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

Formats the value using the given formatter.

impl<N, D: DimName, S: Storage<N, D>> Mul<Unit<Matrix<N, D, U1, S>>> for Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: Unit<Vector<N, D, S>>) -> Self::Output

Performs the * operation.

impl<'a, N, D: DimName, S: Storage<N, D>> Mul<Unit<Matrix<N, D, U1, S>>> for &'a Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: Unit<Vector<N, D, S>>) -> Self::Output

Performs the * operation.

impl<'b, N, D: DimName, S: Storage<N, D>> Mul<&'b Unit<Matrix<N, D, U1, S>>> for Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Unit<Vector<N, D, S>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, D: DimName, S: Storage<N, D>> Mul<&'b Unit<Matrix<N, D, U1, S>>> for &'a Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Unit<Vector<N, D, S>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Mul<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField> Mul<Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField> Mul<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<N: RealField> Mul<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Mul<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField> Mul<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField> Mul<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<N: RealField> Mul<Unit<Quaternion<N>>> for Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField, SB: Storage<N, U3>> Mul<&'b Unit<Matrix<N, U3, U1, SB>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Unit<Vector<N, U3, SB>>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField, SB: Storage<N, U3>> Mul<Unit<Matrix<N, U3, U1, SB>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U3, SB>>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField, SB: Storage<N, U3>> Mul<&'b Unit<Matrix<N, U3, U1, SB>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Unit<Vector<N, U3, SB>>) -> Self::Output

Performs the * operation.

impl<N: RealField, SB: Storage<N, U3>> Mul<Unit<Matrix<N, U3, U1, SB>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U3, SB>>) -> Self::Output

Performs the * operation.

impl<N: RealField> Mul<Unit<Complex<N>>> for UnitComplex<N>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N: RealField> Mul<Unit<Complex<N>>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField> Mul<&'b Unit<Complex<N>>> for UnitComplex<N>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Mul<&'b Unit<Complex<N>>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<N: RealField> Mul<Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField> Mul<Unit<Complex<N>>> for &'a Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField> Mul<&'b Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Mul<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<N: RealField, S: Storage<N, U2>> Mul<Unit<Matrix<N, U2, U1, S>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField, S: Storage<N, U2>> Mul<Unit<Matrix<N, U2, U1, S>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField, S: Storage<N, U2>> Mul<&'b Unit<Matrix<N, U2, U1, S>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField, S: Storage<N, U2>> Mul<&'b Unit<Matrix<N, U2, U1, S>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<N: RealField> Mul<Unit<Complex<N>>> for Translation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Isometry<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, right: UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField> Mul<Unit<Complex<N>>> for &'a Translation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Isometry<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, right: UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField> Mul<&'b Unit<Complex<N>>> for Translation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Isometry<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Mul<&'b Unit<Complex<N>>> for &'a Translation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Isometry<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b UnitComplex<N>) -> Self::Output

Performs the * operation.

impl<N: RealField, D: DimName, R> Mul<Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for Isometry<N, D, R> where
    R: AlgaRotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField, D: DimName, R> Mul<Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for &'a Isometry<N, D, R> where
    R: AlgaRotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField, D: DimName, R> Mul<&'b Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for Isometry<N, D, R> where
    R: AlgaRotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Unit<VectorN<N, D>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for &'a Isometry<N, D, R> where
    R: AlgaRotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D>, 

type Output = Unit<VectorN<N, D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Unit<VectorN<N, D>>) -> Self::Output

Performs the * operation.

impl<N: RealField> Mul<Unit<Quaternion<N>>> for Translation<N, U3> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, N: RealField> Mul<Unit<Quaternion<N>>> for &'a Translation<N, U3> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'b, N: RealField> Mul<&'b Unit<Quaternion<N>>> for Translation<N, U3> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Mul<&'b Unit<Quaternion<N>>> for &'a Translation<N, U3> where
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, 

type Output = Isometry<N, U3, UnitQuaternion<N>>

The resulting type after applying the * operator.

fn mul(self, right: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<N, C: TCategoryMul<TAffine>> Mul<Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, N, C: TCategoryMul<TAffine>> Mul<Unit<Quaternion<N>>> for &'a Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'b, N, C: TCategoryMul<TAffine>> Mul<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N, C: TCategoryMul<TAffine>> Mul<&'b Unit<Quaternion<N>>> for &'a Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: RealField> Div<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'a, N: RealField> Div<Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'b, N: RealField> Div<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<N: RealField> Div<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: RealField> Div<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'a, N: RealField> Div<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'b, N: RealField> Div<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<N: RealField> Div<Unit<Quaternion<N>>> for Rotation<N, U3> where
    DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>, 

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<N: RealField> Div<Unit<Complex<N>>> for UnitComplex<N>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, N: RealField> Div<Unit<Complex<N>>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<'b, N: RealField> Div<&'b Unit<Complex<N>>> for UnitComplex<N>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: RealField> Div<&'b Unit<Complex<N>>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<N: RealField> Div<Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<'a, N: RealField> Div<Unit<Complex<N>>> for &'a Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<'b, N: RealField> Div<&'b Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: RealField> Div<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output

Performs the / operation.

impl<N, C: TCategoryMul<TAffine>> Div<Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'a, N, C: TCategoryMul<TAffine>> Div<Unit<Quaternion<N>>> for &'a Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'b, N, C: TCategoryMul<TAffine>> Div<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N, C: TCategoryMul<TAffine>> Div<&'b Unit<Quaternion<N>>> for &'a Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

type Output = Transform<N, U3, C::Representative>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output

Performs the / operation.

impl<T: Neg> Neg for Unit<T>

type Output = Unit<T::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'b, N: RealField> MulAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)

Performs the *= operation.

impl<N: RealField> MulAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

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

Performs the *= operation.

impl<N: RealField> MulAssign<Unit<Complex<N>>> for UnitComplex<N>

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

Performs the *= operation.

impl<'b, N: RealField> MulAssign<&'b Unit<Complex<N>>> for UnitComplex<N>

fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)

Performs the *= operation.

impl<N: RealField> MulAssign<Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

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

Performs the *= operation.

impl<'b, N: RealField> MulAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)

Performs the *= operation.

impl<N, C: TCategory> MulAssign<Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

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

Performs the *= operation.

impl<'b, N, C: TCategory> MulAssign<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)

Performs the *= operation.

impl<'b, N: RealField> DivAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)

Performs the /= operation.

impl<N: RealField> DivAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    DefaultAllocator: Allocator<N, U4, U1>, 

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

Performs the /= operation.

impl<N: RealField> DivAssign<Unit<Complex<N>>> for UnitComplex<N>

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

Performs the /= operation.

impl<'b, N: RealField> DivAssign<&'b Unit<Complex<N>>> for UnitComplex<N>

fn div_assign(&mut self, rhs: &'b UnitComplex<N>)

Performs the /= operation.

impl<N: RealField> DivAssign<Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

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

Performs the /= operation.

impl<'b, N: RealField> DivAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
    DefaultAllocator: Allocator<N, U2, U2>, 

fn div_assign(&mut self, rhs: &'b UnitComplex<N>)

Performs the /= operation.

impl<N, C: TCategory> DivAssign<Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

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

Performs the /= operation.

impl<'b, N, C: TCategory> DivAssign<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)

Performs the /= operation.

impl<T: Serialize> Serialize for Unit<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Unit<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<N, R: Dim, C: Dim, S> AbsDiffEq<Unit<Matrix<N, R, C, S>>> for Unit<Matrix<N, R, C, S>> where
    N: Scalar + AbsDiffEq,
    S: Storage<N, R, C>,
    N::Epsilon: Copy, 

type Epsilon = N::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

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

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq<Unit<Quaternion<N>>> for UnitQuaternion<N>

type Epsilon = N

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

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

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<N: RealField> AbsDiffEq<Unit<Complex<N>>> for UnitComplex<N>

type Epsilon = N

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

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

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<N, R: Dim, C: Dim, S> RelativeEq<Unit<Matrix<N, R, C, S>>> for Unit<Matrix<N, R, C, S>> where
    N: Scalar + RelativeEq,
    S: Storage<N, R, C>,
    N::Epsilon: Copy, 

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

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

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq<Unit<Quaternion<N>>> for UnitQuaternion<N>

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

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

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<N: RealField> RelativeEq<Unit<Complex<N>>> for UnitComplex<N>

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

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

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<N, R: Dim, C: Dim, S> UlpsEq<Unit<Matrix<N, R, C, S>>> for Unit<Matrix<N, R, C, S>> where
    N: Scalar + UlpsEq,
    S: Storage<N, R, C>,
    N::Epsilon: Copy, 

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: Self::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, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq<Unit<Quaternion<N>>> for UnitQuaternion<N>

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: Self::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, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N: RealField> UlpsEq<Unit<Complex<N>>> for UnitComplex<N>

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: Self::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, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N: RealField, D: DimName> Distribution<Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for Standard where
    DefaultAllocator: Allocator<N, D>,
    StandardNormal: Distribution<N>, 

fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Unit<VectorN<N, D>>

Generate a uniformly distributed random unit vector.

fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<N: RealField> Distribution<Unit<Quaternion<N>>> for Standard where
    OpenClosed01: Distribution<N>, 

fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> UnitQuaternion<N>

Generate a uniformly distributed random rotation quaternion.

fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<N: RealField> Distribution<Unit<Complex<N>>> for Standard where
    OpenClosed01: Distribution<N>, 

fn sample<'a, R: Rng + ?Sized>(&self, rng: &mut R) -> UnitComplex<N>

Generate a uniformly distributed random UnitComplex.

fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T: NormedSpace> SubsetOf<T> for Unit<T> where
    T::Field: RelativeEq, 

fn to_superset(&self) -> T

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(value: &T) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(value: &T) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for Rotation3<N1> where
    N1: RealField,
    N2: RealField + SupersetOf<N1>, 

fn to_superset(&self) -> UnitQuaternion<N2>

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(q: &UnitQuaternion<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(q: &UnitQuaternion<N2>) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2> SubsetOf<Unit<Complex<N2>>> for Rotation2<N1> where
    N1: RealField,
    N2: RealField + SupersetOf<N1>, 

fn to_superset(&self) -> UnitComplex<N2>

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(q: &UnitComplex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(q: &UnitComplex<N2>) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for UnitQuaternion<N1> where
    N1: RealField,
    N2: RealField + SupersetOf<N1>, 

fn to_superset(&self) -> UnitQuaternion<N2>

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2> SubsetOf<Unit<Complex<N2>>> for UnitComplex<N1> where
    N1: RealField,
    N2: RealField + SupersetOf<N1>, 

fn to_superset(&self) -> UnitComplex<N2>

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(uq: &UnitComplex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(uq: &UnitComplex<N2>) -> Self

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.