[−][src]Struct nalgebra::base::Unit
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: Real, 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
) -> Unit<VectorN<N, D>> where
DefaultAllocator: Allocator<N, D>,
[src]
&self,
rhs: &Unit<Vector<N, D, S2>>,
t: N
) -> Unit<VectorN<N, D>> where
DefaultAllocator: Allocator<N, D>,
Computes the spherical linear interpolation between two unit vectors.
pub fn try_slerp<S2: Storage<N, D>>(
&self,
rhs: &Unit<Vector<N, D, S2>>,
t: N,
epsilon: N
) -> Option<Unit<VectorN<N, D>>> where
DefaultAllocator: Allocator<N, D>,
[src]
&self,
rhs: &Unit<Vector<N, D, S2>>,
t: N,
epsilon: N
) -> 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>
[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::Field) -> 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::Field)
[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::Field) -> Option<(Self, T::Field)>
[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::Field
[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) where
T::Field: Real,
[src]
T::Field: Real,
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]
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: PartialEq> PartialEq<Unit<T>> for Unit<T>
[src]
impl<T> AsRef<T> for Unit<T>
[src]
impl<T: Clone> Clone for Unit<T>
[src]
fn clone(&self) -> Unit<T>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<N: Real> From<Unit<Quaternion<N>>> for Matrix4<N>
[src]
fn from(q: UnitQuaternion<N>) -> Self
[src]
impl<N: Real> From<Unit<Quaternion<N>>> for Rotation3<N>
[src]
fn from(q: UnitQuaternion<N>) -> Self
[src]
impl<N: Real> From<Unit<Quaternion<N>>> for Matrix3<N>
[src]
fn from(q: UnitQuaternion<N>) -> Self
[src]
impl<N: Real> From<Unit<Complex<N>>> for Rotation2<N>
[src]
fn from(q: UnitComplex<N>) -> Self
[src]
impl<N: Real> From<Unit<Complex<N>>> for Matrix3<N>
[src]
fn from(q: UnitComplex<N>) -> Matrix3<N>
[src]
impl<N: Real> From<Unit<Complex<N>>> for Matrix2<N>
[src]
fn from(q: UnitComplex<N>) -> Self
[src]
impl<T: Eq> Eq for Unit<T>
[src]
impl<T: Copy> Copy for Unit<T>
[src]
impl<T: Debug> Debug for Unit<T>
[src]
impl<T: Hash> Hash for Unit<T>
[src]
fn hash<__HT: Hasher>(&self, state: &mut __HT)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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> + Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + 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
[src]
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> + Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + 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
[src]
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> + Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + 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
[src]
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> + Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + 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
[src]
impl<'a, 'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output
[src]
impl<'a, N: Real> Mul<Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output
[src]
impl<'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b UnitQuaternion<N>) -> Self::Output
[src]
impl<N: Real> Mul<Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: UnitQuaternion<N>) -> Self::Output
[src]
impl<'a, 'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<'a, N: Real> Mul<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<N: Real> Mul<Unit<Quaternion<N>>> for Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<'a, 'b, N: Real, 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]
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
[src]
impl<'a, N: Real, 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]
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
[src]
impl<'b, N: Real, 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]
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
[src]
impl<N: Real, 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]
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
[src]
impl<N: Real> 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]
impl<'a, N: Real> 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]
impl<'b, N: Real> 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]
impl<'a, 'b, N: Real> 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]
impl<N: Real> Mul<Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: UnitComplex<N>) -> Self::Output
[src]
impl<'a, N: Real> Mul<Unit<Complex<N>>> for &'a Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: UnitComplex<N>) -> Self::Output
[src]
impl<'b, N: Real> Mul<&'b Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
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
[src]
impl<'a, 'b, N: Real> Mul<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
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
[src]
impl<N: Real, S: Storage<N, U2>> Mul<Unit<Matrix<N, U2, U1, S>>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<'a, N: Real, S: Storage<N, U2>> Mul<Unit<Matrix<N, U2, U1, S>>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<'b, N: Real, S: Storage<N, U2>> Mul<&'b Unit<Matrix<N, U2, U1, S>>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<'a, 'b, N: Real, S: Storage<N, U2>> Mul<&'b Unit<Matrix<N, U2, U1, S>>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<N: Real> Mul<Unit<Complex<N>>> for Translation<N, U2> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<'a, N: Real> Mul<Unit<Complex<N>>> for &'a Translation<N, U2> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<'b, N: Real> Mul<&'b Unit<Complex<N>>> for Translation<N, U2> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<'a, 'b, N: Real> Mul<&'b Unit<Complex<N>>> for &'a Translation<N, U2> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
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
[src]
impl<N: Real, 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]
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
[src]
impl<'a, N: Real, 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]
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
[src]
impl<'b, N: Real, 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]
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
[src]
impl<'a, 'b, N: Real, 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]
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
[src]
impl<N: Real> Mul<Unit<Quaternion<N>>> for Translation<N, U3> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
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
[src]
impl<'a, N: Real> Mul<Unit<Quaternion<N>>> for &'a Translation<N, U3> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
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
[src]
impl<'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for Translation<N, U3> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
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
[src]
impl<'a, 'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for &'a Translation<N, U3> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
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
[src]
impl<N, C: TCategoryMul<TAffine>> Mul<Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
impl<'a, N, C: TCategoryMul<TAffine>> Mul<Unit<Quaternion<N>>> for &'a Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
impl<'b, N, C: TCategoryMul<TAffine>> Mul<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
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 + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
impl<'a, 'b, N: Real> Div<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output
[src]
impl<'a, N: Real> Div<Unit<Quaternion<N>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the /
operator.
fn div(self, rhs: UnitQuaternion<N>) -> Self::Output
[src]
impl<'b, N: Real> Div<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b UnitQuaternion<N>) -> Self::Output
[src]
impl<N: Real> Div<Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
type Output = UnitQuaternion<N>
The resulting type after applying the /
operator.
fn div(self, rhs: UnitQuaternion<N>) -> Self::Output
[src]
impl<'a, 'b, N: Real> Div<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<'a, N: Real> Div<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<'b, N: Real> Div<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<N: Real> Div<Unit<Quaternion<N>>> for Rotation<N, U3> where
DefaultAllocator: Allocator<N, U3, U3> + Allocator<N, U4, U1>,
[src]
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
[src]
impl<N: Real> 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]
impl<'a, N: Real> 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]
impl<'b, N: Real> 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]
impl<'a, 'b, N: Real> 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]
impl<N: Real> Div<Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the /
operator.
fn div(self, rhs: UnitComplex<N>) -> Self::Output
[src]
impl<'a, N: Real> Div<Unit<Complex<N>>> for &'a Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the /
operator.
fn div(self, rhs: UnitComplex<N>) -> Self::Output
[src]
impl<'b, N: Real> Div<&'b Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
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
[src]
impl<'a, 'b, N: Real> Div<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
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
[src]
impl<N, C: TCategoryMul<TAffine>> Div<Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
impl<'a, N, C: TCategoryMul<TAffine>> Div<Unit<Quaternion<N>>> for &'a Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
impl<'b, N, C: TCategoryMul<TAffine>> Div<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
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 + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1> + 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
[src]
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]
impl<'b, N: Real> MulAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)
[src]
impl<N: Real> MulAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
fn mul_assign(&mut self, rhs: UnitQuaternion<N>)
[src]
impl<N: Real> MulAssign<Unit<Complex<N>>> for UnitComplex<N>
[src]
fn mul_assign(&mut self, rhs: UnitComplex<N>)
[src]
impl<'b, N: Real> MulAssign<&'b Unit<Complex<N>>> for UnitComplex<N>
[src]
fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)
[src]
impl<N: Real> MulAssign<Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
fn mul_assign(&mut self, rhs: UnitComplex<N>)
[src]
impl<'b, N: Real> MulAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)
[src]
impl<N, C: TCategory> MulAssign<Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
fn mul_assign(&mut self, rhs: UnitQuaternion<N>)
[src]
impl<'b, N, C: TCategory> MulAssign<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)
[src]
impl<'b, N: Real> DivAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)
[src]
impl<N: Real> DivAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U1>,
fn div_assign(&mut self, rhs: UnitQuaternion<N>)
[src]
impl<N: Real> DivAssign<Unit<Complex<N>>> for UnitComplex<N>
[src]
fn div_assign(&mut self, rhs: UnitComplex<N>)
[src]
impl<'b, N: Real> DivAssign<&'b Unit<Complex<N>>> for UnitComplex<N>
[src]
fn div_assign(&mut self, rhs: &'b UnitComplex<N>)
[src]
impl<N: Real> DivAssign<Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
fn div_assign(&mut self, rhs: UnitComplex<N>)
[src]
impl<'b, N: Real> DivAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
DefaultAllocator: Allocator<N, U2, U2>,
[src]
DefaultAllocator: Allocator<N, U2, U2>,
fn div_assign(&mut self, rhs: &'b UnitComplex<N>)
[src]
impl<N, C: TCategory> DivAssign<Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
fn div_assign(&mut self, rhs: UnitQuaternion<N>)
[src]
impl<'b, N, C: TCategory> DivAssign<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>,
fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)
[src]
impl<T> Deref for Unit<T>
[src]
impl<N, R: Dim, C: Dim, S> AbsDiffEq for Unit<Matrix<N, R, C, S>> where
N: Scalar + AbsDiffEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
[src]
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
[src]
fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
[src]
fn abs_diff_ne(&self, other: &Self, epsilon: Self::Epsilon) -> bool
[src]
The inverse of ApproxEq::abs_diff_eq
.
impl<N, R: Dim, C: Dim, S> RelativeEq for Unit<Matrix<N, R, C, S>> where
N: Scalar + RelativeEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
[src]
N: Scalar + RelativeEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
fn default_max_relative() -> Self::Epsilon
[src]
fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of ApproxEq::relative_eq
.
impl<N, R: Dim, C: Dim, S> UlpsEq for Unit<Matrix<N, R, C, S>> where
N: Scalar + UlpsEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
[src]
N: Scalar + UlpsEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
fn default_max_ulps() -> u32
[src]
fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
The inverse of ApproxEq::ulps_eq
.
impl<N: Real, 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]
DefaultAllocator: Allocator<N, D>,
StandardNormal: Distribution<N>,
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]
R: Rng,
Create an iterator that generates random values of T
, using rng
as the source of randomness. Read more
impl<N: Real> Distribution<Unit<Quaternion<N>>> for Standard where
OpenClosed01: Distribution<N>,
[src]
OpenClosed01: Distribution<N>,
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]
R: Rng,
Create an iterator that generates random values of T
, using rng
as the source of randomness. Read more
impl<N: Real> Distribution<Unit<Complex<N>>> for Standard where
OpenClosed01: Distribution<N>,
[src]
OpenClosed01: Distribution<N>,
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]
R: Rng,
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]
T::Field: RelativeEq,
fn to_superset(&self) -> T
[src]
fn is_in_subset(value: &T) -> bool
[src]
unsafe fn from_superset_unchecked(value: &T) -> Self
[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: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> UnitQuaternion<N2>
[src]
fn is_in_subset(q: &UnitQuaternion<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(q: &UnitQuaternion<N2>) -> Self
[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: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> UnitComplex<N2>
[src]
fn is_in_subset(q: &UnitComplex<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(q: &UnitComplex<N2>) -> Self
[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: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> UnitQuaternion<N2>
[src]
fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> Self
[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: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> UnitComplex<N2>
[src]
fn is_in_subset(uq: &UnitComplex<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(uq: &UnitComplex<N2>) -> Self
[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
Blanket Implementations
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> From for T
[src]
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Same for T
[src]
type Output = T
Should always be Self
impl<T> ClosedNeg for T where
T: Neg<Output = T>,
[src]
T: Neg<Output = T>,
impl<T, Right> ClosedMul for T where
T: Mul<Right, Output = T> + MulAssign<Right>,
[src]
T: Mul<Right, Output = T> + MulAssign<Right>,
impl<T, Right> ClosedDiv for T where
T: Div<Right, Output = T> + DivAssign<Right>,
[src]
T: Div<Right, Output = T> + DivAssign<Right>,
impl<SS, SP> SupersetOf for SP where
SS: SubsetOf<SP>,
[src]
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
[src]
fn is_in_subset(&self) -> bool
[src]
unsafe fn to_subset_unchecked(&self) -> SS
[src]
fn from_subset(element: &SS) -> SP
[src]
impl<T> MultiplicativeMagma for T where
T: AbstractMagma<Multiplicative>,
[src]
T: AbstractMagma<Multiplicative>,
impl<T> MultiplicativeQuasigroup for T where
T: AbstractQuasigroup<Multiplicative> + ClosedDiv<T> + MultiplicativeMagma,
[src]
T: AbstractQuasigroup<Multiplicative> + ClosedDiv<T> + MultiplicativeMagma,
impl<T> MultiplicativeLoop for T where
T: AbstractLoop<Multiplicative> + MultiplicativeQuasigroup + One,
[src]
T: AbstractLoop<Multiplicative> + MultiplicativeQuasigroup + One,
impl<T> MultiplicativeSemigroup for T where
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
[src]
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
impl<T> MultiplicativeMonoid for T where
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
[src]
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
impl<T> MultiplicativeGroup for T where
T: AbstractGroup<Multiplicative> + MultiplicativeLoop + MultiplicativeMonoid,
[src]
T: AbstractGroup<Multiplicative> + MultiplicativeLoop + MultiplicativeMonoid,
impl<R, E> Transformation for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
fn transform_point(&self, pt: &E) -> E
[src]
fn transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
impl<R, E> ProjectiveTransformation for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
fn inverse_transform_point(&self, pt: &E) -> E
[src]
fn inverse_transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
impl<R, E> AffineTransformation for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
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]
&self
) -> (Id<Multiplicative>, Id<Multiplicative>, R, Id<Multiplicative>)
fn append_translation(&self, &<R as AffineTransformation<E>>::Translation) -> R
[src]
fn prepend_translation(&self, &<R as AffineTransformation<E>>::Translation) -> R
[src]
fn append_rotation(&self, &<R as AffineTransformation<E>>::Rotation) -> R
[src]
fn prepend_rotation(&self, &<R as AffineTransformation<E>>::Rotation) -> R
[src]
fn append_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
[src]
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
fn prepend_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
[src]
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
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 for R where
E: EuclideanSpace<Real = R>,
R: Real + SubsetOf<R>,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real + SubsetOf<R>,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
type Scaling = R
The type of the pure (uniform) scaling part of this similarity transformation.
fn translation(&self) -> <R as AffineTransformation<E>>::Translation
[src]
fn rotation(&self) -> <R as AffineTransformation<E>>::Rotation
[src]
fn scaling(&self) -> <R as Similarity<E>>::Scaling
[src]
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]
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation's pure rotational part to a vector.
fn scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
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]
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
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]
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation inverse's pure scaling part to a vector.