[][src]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>>[src]

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>, 
[src]

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>, 
[src]

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>[src]

pub fn new_normalize(value: T) -> Self[src]

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

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

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)[src]

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)>
[src]

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[src]

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)[src]

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>[src]

pub fn new_unchecked(value: T) -> Self[src]

Wraps the given value, assuming it is already normalized.

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

Wraps the given reference, assuming it is already normalized.

pub fn into_inner(self) -> T[src]

Retrieves the underlying value.

pub fn unwrap(self) -> T[src]

Deprecated:

use .into_inner() instead

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

pub fn as_mut_unchecked(&mut self) -> &mut T[src]

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>[src]

impl<T> AsRef<T> for Unit<T>[src]

impl<T: Eq> Eq for Unit<T>[src]

impl<T: Clone> Clone for Unit<T>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<T: PartialEq> PartialEq<Unit<T>> for Unit<T>[src]

impl<N: RealField> From<Unit<Quaternion<N>>> for Matrix4<N>[src]

impl<N: RealField> From<Unit<Quaternion<N>>> for Rotation3<N>[src]

impl<N: RealField> From<Unit<Quaternion<N>>> for Matrix3<N>[src]

impl<N: RealField> From<Unit<Complex<N>>> for Rotation2<N>[src]

impl<N: RealField> From<Unit<Complex<N>>> for Matrix3<N>[src]

impl<N: RealField> From<Unit<Complex<N>>> for Matrix2<N>[src]

impl<T> Deref for Unit<T>[src]

type Target = T

The resulting type after dereferencing.

impl<T: Hash> Hash for Unit<T>[src]

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

Feeds a slice of this type into the given [Hasher]. Read more

impl<T: Debug> Debug for Unit<T>[src]

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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>, 
[src]

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector3<N>>

The resulting type after applying the * operator.

impl<N: RealField> Mul<Unit<Complex<N>>> for UnitComplex<N>[src]

type Output = Self

The resulting type after applying the * operator.

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

type Output = UnitComplex<N>

The resulting type after applying the * operator.

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

type Output = Self

The resulting type after applying the * operator.

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

type Output = UnitComplex<N>

The resulting type after applying the * operator.

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

type Output = UnitComplex<N>

The resulting type after applying the * operator.

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

type Output = UnitComplex<N>

The resulting type after applying the * operator.

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

type Output = UnitComplex<N>

The resulting type after applying the * operator.

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

type Output = UnitComplex<N>

The resulting type after applying the * operator.

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

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

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>, 
[src]

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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>, 
[src]

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

The resulting type after applying the * operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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>, 
[src]

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

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

type Output = UnitQuaternion<N>

The resulting type after applying the / operator.

impl<N: RealField> Div<Unit<Complex<N>>> for UnitComplex<N>[src]

type Output = Self

The resulting type after applying the / operator.

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

type Output = UnitComplex<N>

The resulting type after applying the / operator.

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

type Output = Self

The resulting type after applying the / operator.

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

type Output = UnitComplex<N>

The resulting type after applying the / operator.

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

type Output = UnitComplex<N>

The resulting type after applying the / operator.

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

type Output = UnitComplex<N>

The resulting type after applying the / operator.

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

type Output = UnitComplex<N>

The resulting type after applying the / operator.

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

type Output = UnitComplex<N>

The resulting type after applying the / operator.

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>, 
[src]

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

The resulting type after applying the / operator.

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>, 
[src]

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

The resulting type after applying the / operator.

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>, 
[src]

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

The resulting type after applying the / operator.

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>, 
[src]

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

The resulting type after applying the / operator.

impl<T: Neg> Neg for Unit<T>[src]

type Output = Unit<T::Output>

The resulting type after applying the - operator.

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

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

impl<N: RealField> MulAssign<Unit<Complex<N>>> for UnitComplex<N>[src]

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

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

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

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>, 
[src]

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>, 
[src]

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

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

impl<N: RealField> DivAssign<Unit<Complex<N>>> for UnitComplex<N>[src]

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

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

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

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>, 
[src]

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>, 
[src]

impl<T: Serialize> Serialize for Unit<T>[src]

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Unit<T>[src]

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
[src]

type Epsilon = N::Epsilon

Used for specifying relative comparisons.

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

The inverse of ApproxEq::abs_diff_eq.

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

type Epsilon = N

Used for specifying relative comparisons.

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

The inverse of ApproxEq::abs_diff_eq.

impl<N: RealField> AbsDiffEq<Unit<Complex<N>>> for UnitComplex<N>[src]

type Epsilon = N

Used for specifying relative comparisons.

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

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
[src]

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

The inverse of ApproxEq::relative_eq.

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

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

The inverse of ApproxEq::relative_eq.

impl<N: RealField> RelativeEq<Unit<Complex<N>>> for UnitComplex<N>[src]

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

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
[src]

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool[src]

The inverse of ApproxEq::ulps_eq.

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

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool[src]

The inverse of ApproxEq::ulps_eq.

impl<N: RealField> UlpsEq<Unit<Complex<N>>> for UnitComplex<N>[src]

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool[src]

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>, 
[src]

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

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
[src]

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

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

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

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
[src]

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

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

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

Generate a uniformly distributed random UnitComplex.

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

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

impl<T: NormedSpace> SubsetOf<T> for Unit<T> where
    T::Field: RelativeEq
[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Auto Trait Implementations

impl<T> Unpin for Unit<T> where
    T: Unpin

impl<T> Sync for Unit<T> where
    T: Sync

impl<T> Send for Unit<T> where
    T: Send

impl<T> UnwindSafe for Unit<T> where
    T: UnwindSafe

impl<T> RefUnwindSafe for Unit<T> where
    T: RefUnwindSafe

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> DeserializeOwned for T where
    T: Deserialize<'de>, 
[src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<T> ClosedNeg for T where
    T: Neg<Output = T>, 
[src]

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 
[src]

impl<T, Right> ClosedMul<Right> for T where
    T: Mul<Right, Output = T> + MulAssign<Right>, 
[src]

impl<T, Right> ClosedDiv<Right> for T where
    T: Div<Right, Output = T> + DivAssign<Right>, 
[src]

impl<T> MultiplicativeMagma for T where
    T: AbstractMagma<Multiplicative>, 
[src]

impl<T> MultiplicativeQuasigroup for T where
    T: AbstractQuasigroup<Multiplicative> + ClosedDiv<T> + MultiplicativeMagma
[src]

impl<T> MultiplicativeLoop for T where
    T: AbstractLoop<Multiplicative> + MultiplicativeQuasigroup + One
[src]

impl<T> MultiplicativeSemigroup for T where
    T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma
[src]

impl<T> MultiplicativeMonoid for T where
    T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One
[src]

impl<T> MultiplicativeGroup for T where
    T: AbstractGroup<Multiplicative> + MultiplicativeLoop + MultiplicativeMonoid
[src]

impl<R, E> Transformation<E> for R where
    E: EuclideanSpace<RealField = R>,
    R: RealField,
    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,
    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
    <E as EuclideanSpace>::Coordinates: ClosedNeg
[src]

impl<R, E> AffineTransformation<E> for R where
    E: EuclideanSpace<RealField = R>,
    R: RealField,
    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,
    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
    <E as EuclideanSpace>::Coordinates: ClosedNeg
[src]

type Rotation = Id<Multiplicative>

Type of the first rotation to be applied.

type NonUniformScaling = R

Type of the non-uniform scaling to be applied.

type Translation = Id<Multiplicative>

The type of the pure translation part of this affine transformation.

fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>[src]

Appends to this similarity a rotation centered at the point p, i.e., this point is left invariant. Read more

impl<R, E> Similarity<E> for R where
    E: EuclideanSpace<RealField = R>,
    R: RealField + SubsetOf<R>,
    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,
    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
    <E as EuclideanSpace>::Coordinates: ClosedNeg
[src]

type Scaling = R

The type of the pure (uniform) scaling part of this similarity transformation.

fn translate_point(&self, pt: &E) -> E[src]

Applies this transformation's pure translational part to a point.

fn rotate_point(&self, pt: &E) -> E[src]

Applies this transformation's pure rotational part to a point.

fn scale_point(&self, pt: &E) -> E[src]

Applies this transformation's pure scaling part to a point.

fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]

Applies this transformation's pure rotational part to a vector.

fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]

Applies this transformation's pure scaling part to a vector.

fn inverse_translate_point(&self, pt: &E) -> E[src]

Applies this transformation inverse's pure translational part to a point.

fn inverse_rotate_point(&self, pt: &E) -> E[src]

Applies this transformation inverse's pure rotational part to a point.

fn inverse_scale_point(&self, pt: &E) -> E[src]

Applies this transformation inverse's pure scaling part to a point.

fn inverse_rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]

Applies this transformation inverse's pure rotational part to a vector.

fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]

Applies this transformation inverse's pure scaling part to a vector.

impl<R, E> ProjectiveTransformation<E> for R where
    E: EuclideanSpace<RealField = R>,
    R: RealField,
    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,
    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
    <E as EuclideanSpace>::Coordinates: ClosedNeg
[src]