# Type Definition nalgebra::geometry::UnitDualQuaternion[−][src]

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

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

## Implementations

### `impl<T: SimdRealField> UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `pub fn dual_quaternion(&self) -> &DualQuaternion<T>`[src]

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)
));```

#### `#[must_use = "Did you mean to use conjugate_mut()?"]pub fn conjugate(&self) -> Self`[src]

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());```

#### `pub fn conjugate_mut(&mut self)`[src]

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());```

#### `#[must_use = "Did you mean to use inverse_mut()?"]pub fn inverse(&self) -> Self`[src]

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);```

#### `#[must_use = "Did you mean to use inverse_mut()?"]pub fn inverse_mut(&mut self)`[src]

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);```

#### `pub fn isometry_to(&self, other: &Self) -> Self`[src]

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);```

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

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
);```

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

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);```

#### `pub fn sclerp(&self, other: &Self, t: T) -> Self where    T: RealField, `[src]

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);```

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

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

#### `pub fn rotation(&self) -> UnitQuaternion<T>`[src]

Return the rotation part of this unit dual quaternion.

```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
);```

#### `pub fn translation(&self) -> Translation3<T>`[src]

Return the translation part of this unit dual quaternion.

```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
);```

#### `pub fn to_isometry(&self) -> Isometry3<T>`[src]

Builds an isometry from this unit dual quaternion.

```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);```

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

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

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

```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
);```

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

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

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

```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
);```

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

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.

```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
);```

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

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.

```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
);```

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

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.

```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
);```

### `impl<T: SimdRealField + RealField> UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `pub fn to_homogeneous(&self) -> Matrix4<T>`[src]

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

```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);```

### `impl<T: SimdRealField> UnitDualQuaternion<T>`[src]

#### `pub fn identity() -> Self`[src]

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

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

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

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

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());```

### `impl<T: SimdRealField> UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

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

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

```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);```

#### `pub fn from_isometry(isometry: &Isometry3<T>) -> Self`[src]

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

```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);```

#### `pub fn from_rotation(rotation: UnitQuaternion<T>) -> Self`[src]

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

### `impl<T: RealField + AbsDiffEq<Epsilon = T>> AbsDiffEq<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T>`[src]

#### `type Epsilon = T`

Used for specifying relative comparisons.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<'a, 'b, T: SimdRealField> Div<&'b Translation<T, 3_usize>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<'b, T: SimdRealField> Div<&'b Translation<T, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<T: SimdRealField> Div<Isometry<T, Unit<Quaternion<T>>, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<'a, T: SimdRealField> Div<Translation<T, 3_usize>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<T: SimdRealField> Div<Translation<T, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<T: SimdRealField> Div<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

### `impl<T: SimdRealField> Div<Unit<Quaternion<T>>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `/` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<'a, 'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Vector3<T>`

The resulting type after applying the `*` operator.

### `impl<'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Vector3<T>`

The resulting type after applying the `*` operator.

### `impl<'a, 'b, T: SimdRealField> Mul<&'b Point<T, 3_usize>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Point3<T>`

The resulting type after applying the `*` operator.

### `impl<'b, T: SimdRealField> Mul<&'b Point<T, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Point3<T>`

The resulting type after applying the `*` operator.

### `impl<'a, 'b, T: SimdRealField> Mul<&'b Translation<T, 3_usize>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<'b, T: SimdRealField> Mul<&'b Translation<T, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<'a, 'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Unit<Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Unit<Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

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

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Mul<DualQuaternion<T>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

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

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Mul<Isometry<T, Unit<Quaternion<T>>, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<'a, T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Vector3<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Vector3<T>`

The resulting type after applying the `*` operator.

### `impl<'a, T: SimdRealField> Mul<Point<T, 3_usize>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Point3<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Mul<Point<T, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = Point3<T>`

The resulting type after applying the `*` operator.

### `impl<'a, T: SimdRealField> Mul<Translation<T, 3_usize>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Mul<Translation<T, 3_usize>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Mul<Unit<DualQuaternion<T>>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<'a, T: SimdRealField, SB: Storage<T, U3>> Mul<Unit<Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>>> for &'a UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

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

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField, SB: Storage<T, U3>> Mul<Unit<Matrix<T, Const<{ typenum::\$D::USIZE }>, Const<1_usize>, SB>>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

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

The resulting type after applying the `*` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Mul<Unit<Quaternion<T>>> for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `*` operator.

### `impl<T: SimdRealField> Neg for UnitDualQuaternion<T> where    T::Element: SimdRealField, `[src]

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `-` operator.

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

#### `type Output = UnitDualQuaternion<T>`

The resulting type after applying the `-` operator.