# [−][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: Eq> Eq for Unit<T>`[src]

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

#### `fn clone(&self) -> Unit<T>`[src]

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

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

#### `fn as_ref(&self) -> &T`[src]

Performs the conversion.

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

#### `fn eq(&self, other: &Unit<T>) -> bool`[src]

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

#### `fn ne(&self, other: &Unit<T>) -> bool`[src]

This method tests for `!=`.

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

#### `fn from(q: UnitQuaternion<N>) -> Self`[src]

Performs the conversion.

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

#### `fn from(q: UnitQuaternion<N>) -> Self`[src]

Performs the conversion.

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

#### `fn from(q: UnitQuaternion<N>) -> Self`[src]

Performs the conversion.

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

#### `fn from(q: UnitComplex<N>) -> Self`[src]

Performs the conversion.

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

#### `fn from(q: UnitComplex<N>) -> Matrix3<N>`[src]

Performs the conversion.

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

#### `fn from(q: UnitComplex<N>) -> Self`[src]

Performs the conversion.

### `impl<T: Copy> Copy for Unit<T>`[src]

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

#### `fn hash<__H: Hasher>(&self, state: &mut __H)`[src]

Feeds this value into the given [`Hasher`]. Read more

#### `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<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.

#### `fn mul(self, right: Unit<Vector<N, D, S>>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Unit<Vector<N, D, S>>) -> Self::Output`[src]

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

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

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

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

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = UnitQuaternion<N>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = UnitQuaternion<N>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = UnitQuaternion<N>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = Unit<Vector3<N>>`

The resulting type after applying the `*` operator.

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

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

#### `type Output = Unit<Vector3<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Unit<Vector<N, U3, SB>>) -> Self::Output`[src]

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

#### `type Output = Unit<Vector3<N>>`

The resulting type after applying the `*` operator.

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

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

#### `type Output = Unit<Vector3<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Unit<Vector<N, U3, SB>>) -> Self::Output`[src]

Performs the `*` operation.

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

#### `type Output = Self`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Self) -> Self`[src]

Performs the `*` operation.

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

#### `type Output = UnitComplex<N>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

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

#### `type Output = Self`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

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

#### `type Output = Unit<Vector2<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Unit<Vector<N, U2, S>>) -> Self::Output`[src]

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

#### `type Output = Unit<Vector2<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Unit<Vector<N, U2, S>>) -> Self::Output`[src]

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

#### `type Output = Unit<Vector2<N>>`

The resulting type after applying the `*` operator.

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

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

#### `type Output = Unit<Vector2<N>>`

The resulting type after applying the `*` operator.

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

Performs the `*` operation.

### `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.

#### `fn mul(self, right: UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, right: UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, right: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn mul(self, right: &'b UnitComplex<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

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

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

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

The resulting type after applying the `*` operator.

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

Performs the `*` operation.

### `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.

#### `fn mul(self, right: UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, right: UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `*` operation.

### `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.

#### `fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = UnitQuaternion<N>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = UnitQuaternion<N>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

#### `type Output = UnitQuaternion<N>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

Performs the `/` operation.

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

#### `type Output = Self`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Self) -> Self::Output`[src]

Performs the `/` operation.

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

#### `type Output = UnitComplex<N>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: UnitComplex<N>) -> Self::Output`[src]

Performs the `/` operation.

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

#### `type Output = Self`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: UnitComplex<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: UnitComplex<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

Performs the `/` operation.

### `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.

#### `fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

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

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

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output`[src]

Performs the `/` operation.

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

#### `type Output = Unit<T::Output>`

The resulting type after applying the `-` operator.

#### `fn neg(self) -> Self::Output`[src]

Performs the unary `-` operation.

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

#### `fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)`[src]

Performs the `*=` operation.

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

#### `fn mul_assign(&mut self, rhs: UnitQuaternion<N>)`[src]

Performs the `*=` operation.

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

#### `fn mul_assign(&mut self, rhs: UnitComplex<N>)`[src]

Performs the `*=` operation.

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

#### `fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)`[src]

Performs the `*=` operation.

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

#### `fn mul_assign(&mut self, rhs: UnitComplex<N>)`[src]

Performs the `*=` operation.

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

#### `fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)`[src]

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

#### `fn mul_assign(&mut self, rhs: UnitQuaternion<N>)`[src]

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

#### `fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)`[src]

Performs the `*=` operation.

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

#### `fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)`[src]

Performs the `/=` operation.

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

#### `fn div_assign(&mut self, rhs: UnitQuaternion<N>)`[src]

Performs the `/=` operation.

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

#### `fn div_assign(&mut self, rhs: UnitComplex<N>)`[src]

Performs the `/=` operation.

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

#### `fn div_assign(&mut self, rhs: &'b UnitComplex<N>)`[src]

Performs the `/=` operation.

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

#### `fn div_assign(&mut self, rhs: UnitComplex<N>)`[src]

Performs the `/=` operation.

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

#### `fn div_assign(&mut self, rhs: &'b UnitComplex<N>)`[src]

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

#### `fn div_assign(&mut self, rhs: UnitQuaternion<N>)`[src]

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

#### `fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)`[src]

Performs the `/=` operation.

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

#### `type Target = T`

The resulting type after dereferencing.

#### `fn deref(&self) -> &T`[src]

Dereferences the value.

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

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `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 default_epsilon() -> Self::Epsilon`[src]

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

#### `fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool`[src]

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

#### `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 default_epsilon() -> Self::Epsilon`[src]

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

#### `fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool`[src]

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

#### `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 default_epsilon() -> Self::Epsilon`[src]

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

#### `fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool`[src]

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

#### `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 default_max_relative() -> Self::Epsilon`[src]

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

#### `fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool`[src]

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

The inverse of `ApproxEq::relative_eq`.

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

#### `fn default_max_relative() -> Self::Epsilon`[src]

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

#### `fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool`[src]

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

The inverse of `ApproxEq::relative_eq`.

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

#### `fn default_max_relative() -> Self::Epsilon`[src]

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

#### `fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool`[src]

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`[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 default_max_ulps() -> u32`[src]

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

#### `fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool`[src]

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

The inverse of `ApproxEq::ulps_eq`.

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

#### `fn default_max_ulps() -> u32`[src]

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

#### `fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool`[src]

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

The inverse of `ApproxEq::ulps_eq`.

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

#### `fn default_max_ulps() -> u32`[src]

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

#### `fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool`[src]

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`[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 to_superset(&self) -> T`[src]

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

#### `fn is_in_subset(value: &T) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(value: &T) -> Self`[src]

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

#### `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 to_superset(&self) -> UnitQuaternion<N2>`[src]

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

#### `fn is_in_subset(q: &UnitQuaternion<N2>) -> bool`[src]

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

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

#### `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 to_superset(&self) -> UnitComplex<N2>`[src]

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

#### `fn is_in_subset(q: &UnitComplex<N2>) -> bool`[src]

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

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

#### `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 to_superset(&self) -> UnitQuaternion<N2>`[src]

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

#### `fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool`[src]

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

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

#### `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 to_superset(&self) -> UnitComplex<N2>`[src]

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

#### `fn is_in_subset(uq: &UnitComplex<N2>) -> bool`[src]

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

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

#### `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> Send for Unit<T> where
T: Send,`

### `impl<T> Unpin for Unit<T> where
T: Unpin,`

### `impl<T> Sync for Unit<T> where
T: Sync,`

### `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.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

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

#### `fn into(self) -> U`[src]

Performs the conversion.

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

#### `fn from(t: T) -> T`[src]

Performs the conversion.

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

#### `default fn to_string(&self) -> String`[src]

Converts the given value to a `String`. Read more

### `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.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `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.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

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

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

Mutably borrows from an owned value. Read more

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

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

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

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `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]

#### `fn to_subset(&self) -> Option<SS>`[src]

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

#### `fn is_in_subset(&self) -> bool`[src]

Checks if `self` is actually part of its subset `T` (and can be converted to it).

#### `unsafe fn to_subset_unchecked(&self) -> SS`[src]

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

#### `fn from_subset(element: &SS) -> SP`[src]

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

### `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> 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]

#### `fn inverse_transform_point(&self, pt: &E) -> E`[src]

Applies this group's two_sided_inverse action on a point from the euclidean space.

#### `fn inverse_transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates`[src]

Applies this group's two_sided_inverse action on a vector from the euclidean space. Read more

### `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]

#### `fn transform_point(&self, pt: &E) -> E`[src]

Applies this group's action on a point from the euclidean space.

#### `fn transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates`[src]

Applies this group's action on a vector from the euclidean space. 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 translation(&self) -> <R as AffineTransformation<E>>::Translation`[src]

The pure translational component of this similarity transformation.

#### `fn rotation(&self) -> <R as AffineTransformation<E>>::Rotation`[src]

The pure rotational component of this similarity transformation.

#### `fn scaling(&self) -> <R as Similarity<E>>::Scaling`[src]

The pure scaling component 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> 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 decompose(
&self
) -> (Id<Multiplicative>, Id<Multiplicative>, R, Id<Multiplicative>)`[src]

Decomposes this affine transformation into a rotation followed by a non-uniform scaling, followed by a rotation, followed by a translation. Read more

#### `fn append_translation(&self, &<R as AffineTransformation<E>>::Translation) -> R`[src]

Appends a translation to this similarity.

#### `fn prepend_translation(&self, &<R as AffineTransformation<E>>::Translation) -> R`[src]

Prepends a translation to this similarity.

#### `fn append_rotation(&self, &<R as AffineTransformation<E>>::Rotation) -> R`[src]

Appends a rotation to this similarity.

#### `fn prepend_rotation(&self, &<R as AffineTransformation<E>>::Rotation) -> R`[src]

Prepends a rotation to this similarity.

#### `fn append_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R`[src]

Appends a scaling factor to this similarity.

#### `fn prepend_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R`[src]

Prepends a scaling factor to this similarity.

#### `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

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)