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

`type UnitQuaternion<N> = Unit<Quaternion<N>>;`

A unit quaternions. May be used to represent a rotation.

## Methods

### `impl<N: Real> UnitQuaternion<N>`[src]

#### `pub fn into_owned(self) -> UnitQuaternion<N>`[src]

Deprecated

: This method is unnecessary and will be removed in a future release. Use `.clone()` instead.

Moves this unit quaternion into one that owns its data.

#### `pub fn clone_owned(&self) -> UnitQuaternion<N>`[src]

Deprecated

: This method is unnecessary and will be removed in a future release. Use `.clone()` instead.

Clones this unit quaternion into one that owns its data.

#### `pub fn angle(&self) -> N`[src]

The rotation angle in [0; pi] of this unit quaternion.

# Example

```let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = UnitQuaternion::from_axis_angle(&axis, 1.78);
assert_eq!(rot.angle(), 1.78);```

#### `pub fn quaternion(&self) -> &Quaternion<N>`[src]

The underlying quaternion.

Same as `self.as_ref()`.

# Example

```let axis = UnitQuaternion::identity();
assert_eq!(*axis.quaternion(), Quaternion::new(1.0, 0.0, 0.0, 0.0));```

#### `pub fn conjugate(&self) -> UnitQuaternion<N>`[src]

Compute the conjugate of this unit quaternion.

# Example

```let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = UnitQuaternion::from_axis_angle(&axis, 1.78);
let conj = rot.conjugate();
assert_eq!(conj, UnitQuaternion::from_axis_angle(&-axis, 1.78));```

#### `pub fn inverse(&self) -> UnitQuaternion<N>`[src]

Inverts this quaternion if it is not zero.

# Example

```let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = UnitQuaternion::from_axis_angle(&axis, 1.78);
let inv = rot.inverse();
assert_eq!(rot * inv, UnitQuaternion::identity());
assert_eq!(inv * rot, UnitQuaternion::identity());```

#### `pub fn angle_to(&self, other: &UnitQuaternion<N>) -> N`[src]

The rotation angle needed to make `self` and `other` coincide.

# Example

```let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);```

#### `pub fn rotation_to(&self, other: &UnitQuaternion<N>) -> UnitQuaternion<N>`[src]

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

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

# Example

```let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
let rot_to = rot1.rotation_to(&rot2);
assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6);```

#### `pub fn lerp(&self, other: &UnitQuaternion<N>, t: N) -> Quaternion<N>`[src]

Linear interpolation between two unit quaternions.

The result is not normalized.

# Example

```let q1 = UnitQuaternion::new_normalize(Quaternion::new(1.0, 0.0, 0.0, 0.0));
let q2 = UnitQuaternion::new_normalize(Quaternion::new(0.0, 1.0, 0.0, 0.0));
assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(0.9, 0.1, 0.0, 0.0));```

#### `pub fn nlerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>`[src]

Normalized linear interpolation between two unit quaternions.

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

# Example

```let q1 = UnitQuaternion::new_normalize(Quaternion::new(1.0, 0.0, 0.0, 0.0));
let q2 = UnitQuaternion::new_normalize(Quaternion::new(0.0, 1.0, 0.0, 0.0));
assert_eq!(q1.nlerp(&q2, 0.1), UnitQuaternion::new_normalize(Quaternion::new(0.9, 0.1, 0.0, 0.0)));```

#### `pub fn slerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>`[src]

Spherical linear interpolation between two unit quaternions.

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

#### `pub fn try_slerp(    &self,     other: &UnitQuaternion<N>,     t: N,     epsilon: N) -> Option<UnitQuaternion<N>>`[src]

Computes the spherical 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 conjugate_mut(&mut self)`[src]

Compute the conjugate of this unit quaternion in-place.

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

Inverts this quaternion if it is not zero.

# Example

```let axisangle = Vector3::new(0.1, 0.2, 0.3);
let mut rot = UnitQuaternion::new(axisangle);
rot.inverse_mut();
assert_relative_eq!(rot * UnitQuaternion::new(axisangle), UnitQuaternion::identity());
assert_relative_eq!(UnitQuaternion::new(axisangle) * rot, UnitQuaternion::identity());```

#### `pub fn axis(&self) -> Option<Unit<Vector3<N>>>`[src]

The rotation axis of this unit quaternion or `None` if the rotation is zero.

# Example

```let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = UnitQuaternion::from_axis_angle(&axis, angle);
assert_eq!(rot.axis(), Some(axis));

// Case with a zero angle.
let rot = UnitQuaternion::from_axis_angle(&axis, 0.0);
assert!(rot.axis().is_none());```

#### `pub fn scaled_axis(&self) -> Vector3<N>`[src]

The rotation axis of this unit quaternion multiplied by the rotation angle.

# Example

```let axisangle = Vector3::new(0.1, 0.2, 0.3);
let rot = UnitQuaternion::new(axisangle);
assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);```

#### `pub fn axis_angle(&self) -> Option<(Unit<Vector3<N>>, N)>`[src]

The rotation axis and angle in ]0, pi] of this unit quaternion.

Returns `None` if the angle is zero.

# Example

```let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = UnitQuaternion::from_axis_angle(&axis, angle);
assert_eq!(rot.axis_angle(), Some((axis, angle)));

// Case with a zero angle.
let rot = UnitQuaternion::from_axis_angle(&axis, 0.0);
assert!(rot.axis_angle().is_none());```

#### `pub fn exp(&self) -> Quaternion<N>`[src]

Compute the exponential of a quaternion.

Note that this function yields a `Quaternion<N>` because it looses the unit property.

#### `pub fn ln(&self) -> Quaternion<N>`[src]

Compute the natural logarithm of a quaternion.

Note that this function yields a `Quaternion<N>` because it looses the unit property. The vector part of the return value corresponds to the axis-angle representation (divided by 2.0) of this unit quaternion.

# Example

```let axisangle = Vector3::new(0.1, 0.2, 0.3);
let q = UnitQuaternion::new(axisangle);
assert_relative_eq!(q.ln().vector().into_owned(), axisangle, epsilon = 1.0e-6);```

#### `pub fn powf(&self, n: N) -> UnitQuaternion<N>`[src]

Raise the quaternion to a given floating power.

This returns the unit quaternion that identifies a rotation with axis `self.axis()` and angle `self.angle() × n`.

# Example

```let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = UnitQuaternion::from_axis_angle(&axis, angle);
let pow = rot.powf(2.0);
assert_relative_eq!(pow.axis().unwrap(), axis, epsilon = 1.0e-6);
assert_eq!(pow.angle(), 2.4);```

#### `pub fn to_rotation_matrix(&self) -> Rotation<N, U3>`[src]

Builds a rotation matrix from this unit quaternion.

# Example

```let q = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let rot = q.to_rotation_matrix();
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
0.5,       0.8660254, 0.0,
0.0,       0.0,       1.0);

assert_relative_eq!(*rot.matrix(), expected, epsilon = 1.0e-6);```

#### `pub fn to_euler_angles(&self) -> (N, N, N)`[src]

Deprecated

: This is renamed to use `.euler_angles()`.

Converts this unit quaternion into its equivalent Euler angles.

The angles are produced in the form (roll, pitch, yaw).

#### `pub fn euler_angles(&self) -> (N, N, N)`[src]

Retrieves the euler angles corresponding to this unit quaternion.

The angles are produced in the form (roll, pitch, yaw).

# Example

```let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
let euler = rot.euler_angles();
assert_relative_eq!(euler.0, 0.1, epsilon = 1.0e-6);
assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);```

#### `pub fn to_homogeneous(&self) -> MatrixN<N, U4>`[src]

Converts this unit quaternion into its equivalent homogeneous transformation matrix.

# Example

```let rot = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let expected = Matrix4::new(0.8660254, -0.5,      0.0, 0.0,
0.5,       0.8660254, 0.0, 0.0,
0.0,       0.0,       1.0, 0.0,
0.0,       0.0,       0.0, 1.0);

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

### `impl<N: Real> UnitQuaternion<N>`[src]

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

The rotation identity.

# Example

```let q = UnitQuaternion::identity();
let q2 = UnitQuaternion::new(Vector3::new(1.0, 2.0, 3.0));
let v = Vector3::new_random();
let p = Point3::from(v);

assert_eq!(q * q2, q2);
assert_eq!(q2 * q, q2);
assert_eq!(q * v, v);
assert_eq!(q * p, p);```

#### `pub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Self where    SB: Storage<N, U3>, `[src]

Creates a new quaternion from a unit vector (the rotation axis) and an angle (the rotation angle).

# Example

```let axis = Vector3::y_axis();
let angle = f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::from_axis_angle(&axis, angle);

assert_eq!(q.axis().unwrap(), axis);
assert_eq!(q.angle(), angle);
assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(UnitQuaternion::from_scaled_axis(Vector3::<f32>::zeros()), UnitQuaternion::identity());```

#### `pub fn from_quaternion(q: Quaternion<N>) -> Self`[src]

Creates a new unit quaternion from a quaternion.

The input quaternion will be normalized.

#### `pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self`[src]

Creates a new unit quaternion from Euler angles.

The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.

# Example

```let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
let euler = rot.euler_angles();
assert_relative_eq!(euler.0, 0.1, epsilon = 1.0e-6);
assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);```

#### `pub fn from_rotation_matrix(rotmat: &Rotation<N, U3>) -> Self`[src]

Builds an unit quaternion from a rotation matrix.

# Example

```let axis = Vector3::y_axis();
let angle = 0.1;
let rot = Rotation3::from_axis_angle(&axis, angle);
let q = UnitQuaternion::from_rotation_matrix(&rot);
assert_relative_eq!(q.to_rotation_matrix(), rot, epsilon = 1.0e-6);
assert_relative_eq!(q.axis().unwrap(), rot.axis().unwrap(), epsilon = 1.0e-6);
assert_relative_eq!(q.angle(), rot.angle(), epsilon = 1.0e-6);```

#### `pub fn rotation_between<SB, SC>(    a: &Vector<N, U3, SB>,     b: &Vector<N, U3, SC>) -> Option<Self> where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

The unit quaternion needed to make `a` and `b` be collinear and point toward the same direction.

# Example

```let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let q = UnitQuaternion::rotation_between(&a, &b).unwrap();
assert_relative_eq!(q * a, b);
assert_relative_eq!(q.inverse() * b, a);```

#### `pub fn scaled_rotation_between<SB, SC>(    a: &Vector<N, U3, SB>,     b: &Vector<N, U3, SC>,     s: N) -> Option<Self> where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

The smallest rotation needed to make `a` and `b` collinear and point toward the same direction, raised to the power `s`.

# Example

```let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let q2 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.2).unwrap();
let q5 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.5).unwrap();
assert_relative_eq!(q2 * q2 * q2 * q2 * q2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(q5 * q5 * a, b, epsilon = 1.0e-6);```

#### `pub fn rotation_between_axis<SB, SC>(    a: &Unit<Vector<N, U3, SB>>,     b: &Unit<Vector<N, U3, SC>>) -> Option<Self> where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

The unit quaternion needed to make `a` and `b` be collinear and point toward the same direction.

# Example

```let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
let q = UnitQuaternion::rotation_between(&a, &b).unwrap();
assert_relative_eq!(q * a, b);
assert_relative_eq!(q.inverse() * b, a);```

#### `pub fn scaled_rotation_between_axis<SB, SC>(    na: &Unit<Vector<N, U3, SB>>,     nb: &Unit<Vector<N, U3, SC>>,     s: N) -> Option<Self> where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

The smallest rotation needed to make `a` and `b` collinear and point toward the same direction, raised to the power `s`.

# Example

```let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
let q2 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.2).unwrap();
let q5 = UnitQuaternion::scaled_rotation_between(&a, &b, 0.5).unwrap();
assert_relative_eq!(q2 * q2 * q2 * q2 * q2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(q5 * q5 * a, b, epsilon = 1.0e-6);```

#### `pub fn face_towards<SB, SC>(    dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC>) -> Self where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

Creates an unit quaternion that corresponds to the local frame of an observer standing at the origin and looking toward `dir`.

It maps the `z` axis to the direction `dir`.

# Arguments

• dir - The look direction. It does not need to be normalized.
• up - The vertical direction. It does not need to be normalized. The only requirement of this parameter is to not be collinear to `dir`. Non-collinearity is not checked.

# Example

```let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let q = UnitQuaternion::face_towards(&dir, &up);
assert_relative_eq!(q * Vector3::z(), dir.normalize());```

#### `pub fn new_observer_frames<SB, SC>(    dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC>) -> Self where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

Deprecated

: renamed to `face_towards`

#### `pub fn look_at_rh<SB, SC>(    dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC>) -> Self where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

Builds a right-handed look-at view matrix without translation.

It maps the view direction `dir` to the negative `z` axis. This conforms to the common notion of right handed look-at matrix from the computer graphics community.

# Arguments

• dir − The view direction. It does not need to be normalized.
• up - A vector approximately aligned with required the vertical axis. It does not need to be normalized. The only requirement of this parameter is to not be collinear to `dir`.

# Example

```let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let q = UnitQuaternion::look_at_rh(&dir, &up);
assert_relative_eq!(q * dir.normalize(), -Vector3::z());```

#### `pub fn look_at_lh<SB, SC>(    dir: &Vector<N, U3, SB>,     up: &Vector<N, U3, SC>) -> Self where    SB: Storage<N, U3>,    SC: Storage<N, U3>, `[src]

Builds a left-handed look-at view matrix without translation.

It maps the view direction `dir` to the positive `z` axis. This conforms to the common notion of left handed look-at matrix from the computer graphics community.

# Arguments

• dir − The view direction. It does not need to be normalized.
• up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to `dir`.

# Example

```let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let q = UnitQuaternion::look_at_lh(&dir, &up);
assert_relative_eq!(q * dir.normalize(), Vector3::z());```

#### `pub fn new<SB>(axisangle: Vector<N, U3, SB>) -> Self where    SB: Storage<N, U3>, `[src]

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If `axisangle` has a magnitude smaller than `N::default_epsilon()`, this returns the identity rotation.

# Example

```let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::new(axisangle);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(UnitQuaternion::new(Vector3::<f32>::zeros()), UnitQuaternion::identity());```

#### `pub fn new_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self where    SB: Storage<N, U3>, `[src]

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If `axisangle` has a magnitude smaller than `eps`, this returns the identity rotation.

# Example

```let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::new_eps(axisangle, 1.0e-6);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// An almost zero vector yields an identity.
assert_eq!(UnitQuaternion::new_eps(Vector3::new(1.0e-8, 1.0e-9, 1.0e-7), 1.0e-6), UnitQuaternion::identity());```

#### `pub fn from_scaled_axis<SB>(axisangle: Vector<N, U3, SB>) -> Self where    SB: Storage<N, U3>, `[src]

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If `axisangle` has a magnitude smaller than `N::default_epsilon()`, this returns the identity rotation. Same as `Self::new(axisangle)`.

# Example

```let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::from_scaled_axis(axisangle);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(UnitQuaternion::from_scaled_axis(Vector3::<f32>::zeros()), UnitQuaternion::identity());```

#### `pub fn from_scaled_axis_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self where    SB: Storage<N, U3>, `[src]

Creates a new unit quaternion rotation from a rotation axis scaled by the rotation angle.

If `axisangle` has a magnitude smaller than `eps`, this returns the identity rotation. Same as `Self::new_eps(axisangle, eps)`.

# Example

```let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let q = UnitQuaternion::from_scaled_axis_eps(axisangle, 1.0e-6);

assert_relative_eq!(q * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(q * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// An almost zero vector yields an identity.
assert_eq!(UnitQuaternion::from_scaled_axis_eps(Vector3::new(1.0e-8, 1.0e-9, 1.0e-7), 1.0e-6), UnitQuaternion::identity());```

## Trait Implementations

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N: Real> Mul<&'b Rotation<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N: Real> Mul<Rotation<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N: Real> Mul<&'b Rotation<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<N: Real> Mul<Rotation<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N: Real, SB: Storage<N, U3>> Mul<&'b Matrix<N, U3, U1, SB>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N: Real, SB: Storage<N, U3>> Mul<Matrix<N, U3, U1, SB>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N: Real, SB: Storage<N, U3>> Mul<&'b Matrix<N, U3, U1, SB>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<N: Real, SB: Storage<N, U3>> Mul<Matrix<N, U3, U1, SB>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N: Real> Mul<&'b Point<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N: Real> Mul<Point<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N: Real> Mul<&'b Point<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<N: Real> Mul<Point<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

### `impl<N: Real> Mul<Translation<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N: Real> Mul<Translation<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N: Real> Mul<&'b Translation<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N: Real> Mul<&'b Translation<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N: Real> Mul<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N: Real> Mul<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<N: Real> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N: Real> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N: Real> Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N: Real> Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<N, C: TCategoryMul<TAffine>> Mul<Transform<N, U3, C>> for UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, N, C: TCategoryMul<TAffine>> Mul<Transform<N, U3, C>> for &'a UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, N, C: TCategoryMul<TAffine>> Mul<&'b Transform<N, U3, C>> for UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'a, 'b, N, C: TCategoryMul<TAffine>> Mul<&'b Transform<N, U3, C>> for &'a UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `/` operator.

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

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

The resulting type after applying the `/` operator.

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

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

The resulting type after applying the `/` operator.

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

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

The resulting type after applying the `/` operator.

### `impl<'a, 'b, N: Real> Div<&'b Rotation<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, N: Real> Div<Rotation<N, U3>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'b, N: Real> Div<&'b Rotation<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<N: Real> Div<Rotation<N, U3>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'b, N: Real> Div<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, 'b, N: Real> Div<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<N: Real> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, N: Real> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'b, N: Real> Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, 'b, N: Real> Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<N, C: TCategoryMul<TAffine>> Div<Transform<N, U3, C>> for UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, N, C: TCategoryMul<TAffine>> Div<Transform<N, U3, C>> for &'a UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'b, N, C: TCategoryMul<TAffine>> Div<&'b Transform<N, U3, C>> for UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<'a, 'b, N, C: TCategoryMul<TAffine>> Div<&'b Transform<N, U3, C>> for &'a UnitQuaternion<N> where    N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U4, U4> + Allocator<N, U4, U4>, `[src]

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

The resulting type after applying the `/` operator.

### `impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N>`[src]

#### `type Epsilon = N`

Used for specifying relative comparisons.

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

The inverse of `ApproxEq::abs_diff_eq`.

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

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

The inverse of `ApproxEq::relative_eq`.

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

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

The inverse of `ApproxEq::ulps_eq`.

### `impl<N: Real> One for UnitQuaternion<N>`[src]

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

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

### `impl<N: Real> AbstractMagma<Multiplicative> for UnitQuaternion<N>`[src]

#### `fn op(&self, O, lhs: &Self) -> Self`

Performs specific operation.

### `impl<N: Real> AbstractQuasigroup<Multiplicative> for UnitQuaternion<N>`[src]

#### `fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where    Self: RelativeEq, `

Returns `true` if latin squareness holds for the given arguments. Approximate equality is used for verifications. Read more

#### `fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where    Self: Eq, `

Returns `true` if latin squareness holds for the given arguments. Read more

### `impl<N: Real> AbstractSemigroup<Multiplicative> for UnitQuaternion<N>`[src]

#### `fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where    Self: RelativeEq, `

Returns `true` if associativity holds for the given arguments. Approximate equality is used for verifications. Read more

#### `fn prop_is_associative(args: (Self, Self, Self)) -> bool where    Self: Eq, `

Returns `true` if associativity holds for the given arguments.

### `impl<N: Real> AbstractMonoid<Multiplicative> for UnitQuaternion<N>`[src]

#### `fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where    Self: RelativeEq, `

Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications. Read more

#### `fn prop_operating_identity_element_is_noop(args: (Self,)) -> bool where    Self: Eq, `

Checks whether operating with the identity element is a no-op for the given argument. Read more

### `impl<N: Real> Identity<Multiplicative> for UnitQuaternion<N>`[src]

#### `fn id(O) -> Self`

Specific identity.

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

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

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

### `impl<N1, N2> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1> where    N1: Real,    N2: Real + SupersetOf<N1>, `[src]

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

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

### `impl<N1, N2, R> SubsetOf<Isometry<N2, U3, R>> for UnitQuaternion<N1> where    N1: Real,    N2: Real + SupersetOf<N1>,    R: AlgaRotation<Point3<N2>> + SupersetOf<UnitQuaternion<N1>>, `[src]

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

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

### `impl<N1, N2, R> SubsetOf<Similarity<N2, U3, R>> for UnitQuaternion<N1> where    N1: Real,    N2: Real + SupersetOf<N1>,    R: AlgaRotation<Point3<N2>> + SupersetOf<UnitQuaternion<N1>>, `[src]

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

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

### `impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1> where    N1: Real,    N2: Real + SupersetOf<N1>,    C: SuperTCategoryOf<TAffine>, `[src]

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

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

### `impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for UnitQuaternion<N1>`[src]

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

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

### `impl<N: Real> AffineTransformation<Point<N, U3>> for UnitQuaternion<N>`[src]

#### `type Rotation = Self`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id`

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

#### `fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>`

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

### `impl<N: Real> Similarity<Point<N, U3>> for UnitQuaternion<N>`[src]

#### `type Scaling = Id`

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

#### `fn translate_point(&self, pt: &E) -> E`

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

#### `fn rotate_point(&self, pt: &E) -> E`

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

#### `fn scale_point(&self, pt: &E) -> E`

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

#### `fn rotate_vector(    &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`

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

#### `fn inverse_translate_point(&self, pt: &E) -> E`

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

#### `fn inverse_rotate_point(&self, pt: &E) -> E`

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

#### `fn inverse_scale_point(&self, pt: &E) -> E`

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`

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`

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