UnitDualQuaternion in nalgebra::geometry - Rust
Description: A unit dual quaternion. May be used to represent a rotation followed by a translation.
Keywords: rust, rustlang, rust-lang, UnitDualQuaternion

# Type Definition nalgebra::geometry::UnitDualQuaternion

source ·

    pub type UnitDualQuaternion<T> = Unit<DualQuaternion<T>>;

Expand description

A unit dual quaternion. May be used to represent a rotation followed by a translation.

## Implementations§

source§

### impl<T: SimdRealField> UnitDualQuaternion<T>where
T::Element: SimdRealField,

source

#### pub fn dual_quaternion(&self) -> &DualQuaternion<T>

The underlying dual quaternion.

Same as `self.as_ref()`.

##### Example

    let id = UnitDualQuaternion::identity();
    assert_eq!(*id.dual_quaternion(), DualQuaternion::from_real_and_dual(
        Quaternion::new(1.0, 0.0, 0.0, 0.0),
        Quaternion::new(0.0, 0.0, 0.0, 0.0)
    ));

source

#### pub fn conjugate(&self) -> Self

Compute the conjugate of this unit quaternion.

##### Example

    let qr = Quaternion::new(1.0, 2.0, 3.0, 4.0);
    let qd = Quaternion::new(5.0, 6.0, 7.0, 8.0);
    let unit = UnitDualQuaternion::new_normalize(
        DualQuaternion::from_real_and_dual(qr, qd)
    );
    let conj = unit.conjugate();
    assert_eq!(conj.real, unit.real.conjugate());
    assert_eq!(conj.dual, unit.dual.conjugate());

source

#### pub fn conjugate_mut(&mut self)

Compute the conjugate of this unit quaternion in-place.

##### Example

    let qr = Quaternion::new(1.0, 2.0, 3.0, 4.0);
    let qd = Quaternion::new(5.0, 6.0, 7.0, 8.0);
    let unit = UnitDualQuaternion::new_normalize(
        DualQuaternion::from_real_and_dual(qr, qd)
    );
    let mut conj = unit.clone();
    conj.conjugate_mut();
    assert_eq!(conj.as_ref().real, unit.as_ref().real.conjugate());
    assert_eq!(conj.as_ref().dual, unit.as_ref().dual.conjugate());

source

#### pub fn inverse(&self) -> Self

Inverts this dual quaternion if it is not zero.

##### Example

    let qr = Quaternion::new(1.0, 2.0, 3.0, 4.0);
    let qd = Quaternion::new(5.0, 6.0, 7.0, 8.0);
    let unit = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(qr, qd));
    let inv = unit.inverse();
    assert_relative_eq!(unit * inv, UnitDualQuaternion::identity(), epsilon = 1.0e-6);
    assert_relative_eq!(inv * unit, UnitDualQuaternion::identity(), epsilon = 1.0e-6);

source

#### pub fn inverse_mut(&mut self)

Inverts this dual quaternion in place if it is not zero.

##### Example

    let qr = Quaternion::new(1.0, 2.0, 3.0, 4.0);
    let qd = Quaternion::new(5.0, 6.0, 7.0, 8.0);
    let unit = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(qr, qd));
    let mut inv = unit.clone();
    inv.inverse_mut();
    assert_relative_eq!(unit * inv, UnitDualQuaternion::identity(), epsilon = 1.0e-6);
    assert_relative_eq!(inv * unit, UnitDualQuaternion::identity(), epsilon = 1.0e-6);

source

#### pub fn isometry_to(&self, other: &Self) -> Self

The unit dual quaternion needed to make `self` and `other` coincide.

The result is such that: `self.isometry_to(other) * self == other`.

##### Example

    let qr = Quaternion::new(1.0, 2.0, 3.0, 4.0);
    let qd = Quaternion::new(5.0, 6.0, 7.0, 8.0);
    let dq1 = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(qr, qd));
    let dq2 = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(qd, qr));
    let dq_to = dq1.isometry_to(&dq2);
    assert_relative_eq!(dq_to * dq1, dq2, epsilon = 1.0e-6);

source

#### pub fn lerp(&self, other: &Self, t: T) -> DualQuaternion<T>

Linear interpolation between two unit dual quaternions.

The result is not normalized.

##### Example

    let dq1 = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(
        Quaternion::new(0.5, 0.0, 0.5, 0.0),
        Quaternion::new(0.0, 0.5, 0.0, 0.5)
    ));
    let dq2 = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(
        Quaternion::new(0.5, 0.0, 0.0, 0.5),
        Quaternion::new(0.5, 0.0, 0.5, 0.0)
    ));
    assert_relative_eq!(
        UnitDualQuaternion::new_normalize(dq1.lerp(&dq2, 0.5)),
        UnitDualQuaternion::new_normalize(
            DualQuaternion::from_real_and_dual(
                Quaternion::new(0.5, 0.0, 0.25, 0.25),
                Quaternion::new(0.25, 0.25, 0.25, 0.25)
            )
        ),
        epsilon = 1.0e-6
    );

source

#### pub fn nlerp(&self, other: &Self, t: T) -> Self

Normalized linear interpolation between two unit quaternions.

This is the same as `self.lerp` except that the result is normalized.

##### Example

    let dq1 = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(
        Quaternion::new(0.5, 0.0, 0.5, 0.0),
        Quaternion::new(0.0, 0.5, 0.0, 0.5)
    ));
    let dq2 = UnitDualQuaternion::new_normalize(DualQuaternion::from_real_and_dual(
        Quaternion::new(0.5, 0.0, 0.0, 0.5),
        Quaternion::new(0.5, 0.0, 0.5, 0.0)
    ));
    assert_relative_eq!(dq1.nlerp(&dq2, 0.2), UnitDualQuaternion::new_normalize(
        DualQuaternion::from_real_and_dual(
            Quaternion::new(0.5, 0.0, 0.4, 0.1),
            Quaternion::new(0.1, 0.4, 0.1, 0.4)
        )
    ), epsilon = 1.0e-6);

source

#### pub fn sclerp(&self, other: &Self, t: T) -> Selfwhere
T: RealField,

Screw linear interpolation between two unit quaternions. This creates a smooth arc from one dual-quaternion to another.

Panics if the angle between both quaternion is 180 degrees (in which case the interpolation is not well-defined). Use `.try_sclerp` instead to avoid the panic.

##### Example

    let dq1 = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0),
    );

    let dq2 = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 0.0, 3.0).into(),
        UnitQuaternion::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0),
    );

    let dq = dq1.sclerp(&dq2, 1.0 / 3.0);

    assert_relative_eq!(
        dq.rotation().euler_angles().0, std::f32::consts::FRAC_PI_2, epsilon = 1.0e-6
    );
    assert_relative_eq!(dq.translation().vector.y, 3.0, epsilon = 1.0e-6);

source

#### pub fn try_sclerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>where
T: RealField,

Computes the screw-linear interpolation between two unit quaternions or returns `None` if both quaternions are approximately 180 degrees apart (in which case the interpolation is not well-defined).

##### Arguments

- `self`: the first quaternion to interpolate from.
- `other`: the second quaternion to interpolate toward.
- `t`: the interpolation parameter. Should be between 0 and 1.
- `epsilon`: the value below which the sinus of the angle separating both quaternion must be to return `None`.

source

#### pub fn rotation(&self) -> UnitQuaternion<T>

Return the rotation part of this unit dual quaternion.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0)
    );

    assert_relative_eq!(
        dq.rotation().angle(), std::f32::consts::FRAC_PI_4, epsilon = 1.0e-6
    );

source

#### pub fn translation(&self) -> Translation3<T>

Return the translation part of this unit dual quaternion.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0)
    );

    assert_relative_eq!(
        dq.translation().vector, Vector3::new(0.0, 3.0, 0.0), epsilon = 1.0e-6
    );

source

#### pub fn to_isometry(self) -> Isometry3<T>

Builds an isometry from this unit dual quaternion.

##### Example

    let rotation = UnitQuaternion::from_euler_angles(std::f32::consts::PI, 0.0, 0.0);
    let translation = Vector3::new(1.0, 3.0, 2.5);
    let dq = UnitDualQuaternion::from_parts(
        translation.into(),
        rotation
    );
    let iso = dq.to_isometry();

    assert_relative_eq!(iso.rotation.angle(), std::f32::consts::PI, epsilon = 1.0e-6);
    assert_relative_eq!(iso.translation.vector, translation, epsilon = 1.0e-6);

source

#### pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T>

Rotate and translate a point by this unit dual quaternion interpreted as an isometry.

This is the same as the multiplication `self * pt`.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let point = Point3::new(1.0, 2.0, 3.0);

    assert_relative_eq!(
        dq.transform_point(&point), Point3::new(1.0, 0.0, 2.0), epsilon = 1.0e-6
    );

source

#### pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T>

Rotate a vector by this unit dual quaternion, ignoring the translational component.

This is the same as the multiplication `self * v`.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let vector = Vector3::new(1.0, 2.0, 3.0);

    assert_relative_eq!(
        dq.transform_vector(&vector), Vector3::new(1.0, -3.0, 2.0), epsilon = 1.0e-6
    );

source

#### pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T>

Rotate and translate a point by the inverse of this unit quaternion.

This may be cheaper than inverting the unit dual quaternion and transforming the point.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let point = Point3::new(1.0, 2.0, 3.0);

    assert_relative_eq!(
        dq.inverse_transform_point(&point), Point3::new(1.0, 3.0, 1.0), epsilon = 1.0e-6
    );

source

#### pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T>

Rotate a vector by the inverse of this unit quaternion, ignoring the translational component.

This may be cheaper than inverting the unit dual quaternion and transforming the vector.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let vector = Vector3::new(1.0, 2.0, 3.0);

    assert_relative_eq!(
        dq.inverse_transform_vector(&vector), Vector3::new(1.0, 3.0, -2.0), epsilon = 1.0e-6
    );

source

#### pub fn inverse_transform_unit_vector(
&self,
v: &Unit<Vector3<T>>
) -> Unit<Vector3<T>>

Rotate a unit vector by the inverse of this unit quaternion, ignoring the translational component. This may be cheaper than inverting the unit dual quaternion and transforming the vector.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let vector = Unit::new_unchecked(Vector3::new(0.0, 1.0, 0.0));

    assert_relative_eq!(
        dq.inverse_transform_unit_vector(&vector),
        Unit::new_unchecked(Vector3::new(0.0, 0.0, -1.0)),
        epsilon = 1.0e-6
    );

source§

### impl<T: SimdRealField + RealField> UnitDualQuaternion<T>where
T::Element: SimdRealField,

source

#### pub fn to_homogeneous(self) -> Matrix4<T>

Converts this unit dual quaternion interpreted as an isometry into its equivalent homogeneous transformation matrix.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(1.0, 3.0, 2.0).into(),
        UnitQuaternion::from_axis_angle(&Vector3::z_axis(), std::f32::consts::FRAC_PI_6)
    );
    let expected = Matrix4::new(0.8660254, -0.5,      0.0, 1.0,
                                0.5,       0.8660254, 0.0, 3.0,
                                0.0,       0.0,       1.0, 2.0,
                                0.0,       0.0,       0.0, 1.0);

    assert_relative_eq!(dq.to_homogeneous(), expected, epsilon = 1.0e-6);

source§

### impl<T: SimdRealField> UnitDualQuaternion<T>

source

#### pub fn identity() -> Self

The unit dual quaternion multiplicative identity, which also represents the identity transformation as an isometry.

##### Example

    let ident = UnitDualQuaternion::identity();
    let point = Point3::new(1.0, -4.3, 3.33);

    assert_eq!(ident * point, point);
    assert_eq!(ident, ident.inverse());

source

#### pub fn cast<To: Scalar>(self) -> UnitDualQuaternion<To>where
UnitDualQuaternion<To>: SupersetOf<Self>,

Cast the components of `self` to another type.

##### Example

    let q = UnitDualQuaternion::<f64>::identity();
    let q2 = q.cast::<f32>();
    assert_eq!(q2, UnitDualQuaternion::<f32>::identity());

source§

### impl<T: SimdRealField> UnitDualQuaternion<T>where
T::Element: SimdRealField,

source

#### pub fn from_parts(
translation: Translation3<T>,
rotation: UnitQuaternion<T>
) -> Self

Return a dual quaternion representing the translation and orientation given by the provided rotation quaternion and translation vector.

##### Example

    let dq = UnitDualQuaternion::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let point = Point3::new(1.0, 2.0, 3.0);

    assert_relative_eq!(dq * point, Point3::new(1.0, 0.0, 2.0), epsilon = 1.0e-6);

source

#### pub fn from_isometry(isometry: &Isometry3<T>) -> Self

Return a unit dual quaternion representing the translation and orientation given by the provided isometry.

##### Example

    let iso = Isometry3::from_parts(
        Vector3::new(0.0, 3.0, 0.0).into(),
        UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_2, 0.0, 0.0)
    );
    let dq = UnitDualQuaternion::from_isometry(&iso);
    let point = Point3::new(1.0, 2.0, 3.0);

    assert_relative_eq!(dq * point, iso * point, epsilon = 1.0e-6);

source

#### pub fn from_rotation(rotation: UnitQuaternion<T>) -> Self

Creates a dual quaternion from a unit quaternion rotation.

##### Example

    let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
    let rot = UnitQuaternion::new_normalize(q);

    let dq = UnitDualQuaternion::from_rotation(rot);
    assert_relative_eq!(dq.as_ref().real.norm(), 1.0, epsilon = 1.0e-6);
    assert_eq!(dq.as_ref().dual.norm(), 0.0);

## Trait Implementations§

source§

### impl<T: RealField + AbsDiffEq<Epsilon = T>> AbsDiffEq<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>

§

#### type Epsilon = T

Used for specifying relative comparisons.
source§

#### fn default_epsilon() -> Self::Epsilon

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

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

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

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

The inverse of `AbsDiffEq::abs_diff_eq`.
source§

### impl<T: RealField> Default for UnitDualQuaternion<T>

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

### impl<T: RealField + Display> Display for UnitDualQuaternion<T>

source§

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

Formats the value using the given formatter. Read more
source§

### impl<'a, 'b, T: SimdRealField> Div<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: &'b Isometry3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'b, T: SimdRealField> Div<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: &'b Isometry3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Div<&'b Translation<T, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: &'b Translation3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'b, T: SimdRealField> Div<&'b Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: &'b Translation3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Div<&'b Unit<DualQuaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: &'b UnitDualQuaternion<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'b, T: SimdRealField> Div<&'b Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: &'b UnitDualQuaternion<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Div<&'b Unit<Quaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

### impl<'b, T: SimdRealField> Div<&'b Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

### impl<'a, T: SimdRealField> Div<Isometry<T, Unit<Quaternion<T>>, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Isometry3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: SimdRealField> Div<Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Isometry3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'a, T: SimdRealField> Div<Translation<T, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Translation3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: SimdRealField> Div<Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Translation3<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'a, T: SimdRealField> Div<Unit<DualQuaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: UnitDualQuaternion<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<T: SimdRealField> Div<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: UnitDualQuaternion<T>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<'a, T: SimdRealField> Div<Unit<Quaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

### impl<T: SimdRealField> Div<Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

### impl<'b, T: SimdRealField> DivAssign<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn div_assign(&mut self, rhs: &'b Isometry3<T>)

Performs the `/=` operation. Read more
source§

### impl<'b, T: SimdRealField> DivAssign<&'b Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn div_assign(&mut self, rhs: &'b Translation3<T>)

Performs the `/=` operation. Read more
source§

### impl<'b, T: SimdRealField> DivAssign<&'b Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn div_assign(&mut self, rhs: &'b UnitDualQuaternion<T>)

Performs the `/=` operation. Read more
source§

### impl<'b, T: SimdRealField> DivAssign<&'b Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

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

Performs the `/=` operation. Read more
source§

### impl<T: SimdRealField> DivAssign<Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn div_assign(&mut self, rhs: Isometry3<T>)

Performs the `/=` operation. Read more
source§

### impl<T: SimdRealField> DivAssign<Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn div_assign(&mut self, rhs: Translation3<T>)

Performs the `/=` operation. Read more
source§

### impl<T: SimdRealField> DivAssign<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn div_assign(&mut self, rhs: UnitDualQuaternion<T>)

Performs the `/=` operation. Read more
source§

### impl<T: SimdRealField> DivAssign<Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

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

Performs the `/=` operation. Read more
source§

### impl<T: SimdRealField> From<Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn from(iso: Isometry3<T>) -> Self

Converts to this type from the input type.
source§

### impl<'a, 'b, T: SimdRealField> Mul<&'b DualQuaternion<T>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = DualQuaternion<T>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b DualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> Mul<&'b DualQuaternion<T>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = DualQuaternion<T>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b DualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Mul<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b Isometry3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> Mul<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b Isometry3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Mul<&'b OPoint<T, Const<3>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = OPoint<T, Const<3>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b Point3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> Mul<&'b OPoint<T, Const<3>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = OPoint<T, Const<3>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b Point3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Mul<&'b Translation<T, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b Translation3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> Mul<&'b Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b Translation3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Mul<&'b Unit<DualQuaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b UnitDualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> Mul<&'b Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: &'b UnitDualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Unit<Matrix<T, Const<3>, Const<1>, SB>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Unit<Matrix<T, Const<3>, Const<1>, SB>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'a, 'b, T: SimdRealField> Mul<&'b Unit<Quaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> Mul<&'b Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField> Mul<DualQuaternion<T>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = DualQuaternion<T>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: DualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField> Mul<DualQuaternion<T>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = DualQuaternion<T>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: DualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField> Mul<Isometry<T, Unit<Quaternion<T>>, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Isometry3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField> Mul<Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Isometry3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField> Mul<OPoint<T, Const<3>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = OPoint<T, Const<3>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Point3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField> Mul<OPoint<T, Const<3>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = OPoint<T, Const<3>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Point3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField> Mul<Translation<T, 3>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Translation3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField> Mul<Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Translation3<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField> Mul<Unit<DualQuaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: UnitDualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField> Mul<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: UnitDualQuaternion<T>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField, SB: Storage<T, U3>> Mul<Unit<Matrix<T, Const<3>, Const<1>, SB>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField, SB: Storage<T, U3>> Mul<Unit<Matrix<T, Const<3>, Const<1>, SB>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<Matrix<T, Const<3>, Const<1>, ArrayStorage<T, 3, 1>>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'a, T: SimdRealField> Mul<Unit<Quaternion<T>>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<T: SimdRealField> Mul<Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<'b, T: SimdRealField> MulAssign<&'b Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn mul_assign(&mut self, rhs: &'b Isometry3<T>)

Performs the `*=` operation. Read more
source§

### impl<'b, T: SimdRealField> MulAssign<&'b Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn mul_assign(&mut self, rhs: &'b Translation3<T>)

Performs the `*=` operation. Read more
source§

### impl<'b, T: SimdRealField> MulAssign<&'b Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn mul_assign(&mut self, rhs: &'b UnitDualQuaternion<T>)

Performs the `*=` operation. Read more
source§

### impl<'b, T: SimdRealField> MulAssign<&'b Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

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

Performs the `*=` operation. Read more
source§

### impl<T: SimdRealField> MulAssign<Isometry<T, Unit<Quaternion<T>>, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn mul_assign(&mut self, rhs: Isometry3<T>)

Performs the `*=` operation. Read more
source§

### impl<T: SimdRealField> MulAssign<Translation<T, 3>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn mul_assign(&mut self, rhs: Translation3<T>)

Performs the `*=` operation. Read more
source§

### impl<T: SimdRealField> MulAssign<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn mul_assign(&mut self, rhs: UnitDualQuaternion<T>)

Performs the `*=` operation. Read more
source§

### impl<T: SimdRealField> MulAssign<Unit<Quaternion<T>>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

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

Performs the `*=` operation. Read more
source§

### impl<'a, T: SimdRealField> Neg for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

### impl<T: SimdRealField> Neg for UnitDualQuaternion<T>where
T::Element: SimdRealField,

§

#### type Output = Unit<DualQuaternion<T>>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

### impl<T: SimdRealField> One for UnitDualQuaternion<T>where
T::Element: SimdRealField,

source§

#### fn one() -> Self

Returns the multiplicative identity element of `Self`, `1`. Read more
source§

#### fn set_one(&mut self)

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

#### fn is_one(&self) -> bool where
Self: PartialEq<Self>,

Returns `true` if `self` is equal to the multiplicative identity. Read more
source§

### impl<T: Scalar + ClosedNeg + PartialEq + SimdRealField> PartialEq<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>

source§

#### fn eq(&self, rhs: &Self) -> bool

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

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more
source§

### impl<T: RealField + RelativeEq<Epsilon = T>> RelativeEq<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>

source§

#### fn default_max_relative() -> Self::Epsilon

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

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

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

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

The inverse of `RelativeEq::relative_eq`.
source§

### impl<T1, T2> SubsetOf<Isometry<T2, Unit<Quaternion<T2>>, 3>> for UnitDualQuaternion<T1>where
T1: RealField,
T2: RealField + SupersetOf<T1>,

source§

#### fn to_superset(&self) -> Isometry3<T2>

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

#### fn is_in_subset(iso: &Isometry3<T2>) -> bool

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

#### fn from_superset_unchecked(iso: &Isometry3<T2>) -> Self

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

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

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

### impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<4>, Const<4>, ArrayStorage<T2, 4, 4>>> for UnitDualQuaternion<T1>

source§

#### fn to_superset(&self) -> Matrix4<T2>

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

#### fn is_in_subset(m: &Matrix4<T2>) -> bool

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

#### fn from_superset_unchecked(m: &Matrix4<T2>) -> Self

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

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

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

### impl<T1, T2> SubsetOf<Similarity<T2, Unit<Quaternion<T2>>, 3>> for UnitDualQuaternion<T1>where
T1: RealField,
T2: RealField + SupersetOf<T1>,

source§

#### fn to_superset(&self) -> Similarity3<T2>

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

#### fn is_in_subset(sim: &Similarity3<T2>) -> bool

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

#### fn from_superset_unchecked(sim: &Similarity3<T2>) -> Self

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

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

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

### impl<T1, T2, C> SubsetOf<Transform<T2, C, 3>> for UnitDualQuaternion<T1>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
C: SuperTCategoryOf<TAffine>,

source§

#### fn to_superset(&self) -> Transform<T2, C, 3>

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

#### fn is_in_subset(t: &Transform<T2, C, 3>) -> bool

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

#### fn from_superset_unchecked(t: &Transform<T2, C, 3>) -> Self

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

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

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

### impl<T1, T2> SubsetOf<Unit<DualQuaternion<T2>>> for UnitDualQuaternion<T1>where
T1: SimdRealField,
T2: SimdRealField + SupersetOf<T1>,

source§

#### fn to_superset(&self) -> UnitDualQuaternion<T2>

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

#### fn is_in_subset(dq: &UnitDualQuaternion<T2>) -> bool

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

#### fn from_superset_unchecked(dq: &UnitDualQuaternion<T2>) -> Self

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

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

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

### impl<T: RealField + UlpsEq<Epsilon = T>> UlpsEq<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>

source§

#### fn default_max_ulps() -> u32

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

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

A test for equality that uses units in the last place (ULP) if the values are far apart.
source§

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

The inverse of `UlpsEq::ulps_eq`.
source§

### impl<T: Scalar + ClosedNeg + Eq + SimdRealField> Eq for UnitDualQuaternion<T>