Type Definition nalgebra::geometry::UnitQuaternion
source · pub type UnitQuaternion<N> = Unit<Quaternion<N>>;
Expand description
A unit quaternions. May be used to represent a rotation.
Implementations§
source§impl<N: Real> UnitQuaternion<N>
impl<N: Real> UnitQuaternion<N>
sourcepub fn into_owned(self) -> UnitQuaternion<N>
👎Deprecated: This method is unnecessary and will be removed in a future release. Use .clone()
instead.
pub fn into_owned(self) -> UnitQuaternion<N>
.clone()
instead.Moves this unit quaternion into one that owns its data.
sourcepub fn clone_owned(&self) -> UnitQuaternion<N>
👎Deprecated: This method is unnecessary and will be removed in a future release. Use .clone()
instead.
pub fn clone_owned(&self) -> UnitQuaternion<N>
.clone()
instead.Clones this unit quaternion into one that owns its data.
sourcepub fn angle(&self) -> N
pub fn angle(&self) -> N
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);
sourcepub fn quaternion(&self) -> &Quaternion<N>
pub fn quaternion(&self) -> &Quaternion<N>
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));
sourcepub fn conjugate(&self) -> UnitQuaternion<N>
pub fn conjugate(&self) -> UnitQuaternion<N>
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));
sourcepub fn inverse(&self) -> UnitQuaternion<N>
pub fn inverse(&self) -> UnitQuaternion<N>
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());
sourcepub fn angle_to(&self, other: &UnitQuaternion<N>) -> N
pub fn angle_to(&self, other: &UnitQuaternion<N>) -> N
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);
sourcepub fn rotation_to(&self, other: &UnitQuaternion<N>) -> UnitQuaternion<N>
pub fn rotation_to(&self, other: &UnitQuaternion<N>) -> UnitQuaternion<N>
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);
sourcepub fn lerp(&self, other: &UnitQuaternion<N>, t: N) -> Quaternion<N>
pub fn lerp(&self, other: &UnitQuaternion<N>, t: N) -> Quaternion<N>
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));
sourcepub fn nlerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>
pub fn nlerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>
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)));
sourcepub fn slerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>
pub fn slerp(&self, other: &UnitQuaternion<N>, t: N) -> UnitQuaternion<N>
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.
sourcepub fn try_slerp(
&self,
other: &UnitQuaternion<N>,
t: N,
epsilon: N
) -> Option<UnitQuaternion<N>>
pub fn try_slerp(
&self,
other: &UnitQuaternion<N>,
t: N,
epsilon: N
) -> Option<UnitQuaternion<N>>
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 returnNone
.
sourcepub fn conjugate_mut(&mut self)
pub fn conjugate_mut(&mut self)
Compute the conjugate of this unit quaternion in-place.
sourcepub fn inverse_mut(&mut self)
pub fn inverse_mut(&mut self)
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());
sourcepub fn axis(&self) -> Option<Unit<Vector3<N>>>
pub fn axis(&self) -> Option<Unit<Vector3<N>>>
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());
sourcepub fn scaled_axis(&self) -> Vector3<N>
pub fn scaled_axis(&self) -> Vector3<N>
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);
sourcepub fn axis_angle(&self) -> Option<(Unit<Vector3<N>>, N)>
pub fn axis_angle(&self) -> Option<(Unit<Vector3<N>>, N)>
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());
sourcepub fn exp(&self) -> Quaternion<N>
pub fn exp(&self) -> Quaternion<N>
Compute the exponential of a quaternion.
Note that this function yields a Quaternion<N>
because it looses the unit property.
sourcepub fn ln(&self) -> Quaternion<N>
pub fn ln(&self) -> Quaternion<N>
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);
sourcepub fn powf(&self, n: N) -> UnitQuaternion<N>
pub fn powf(&self, n: N) -> UnitQuaternion<N>
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);
sourcepub fn to_rotation_matrix(&self) -> Rotation<N, U3>
pub fn to_rotation_matrix(&self) -> Rotation<N, U3>
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);
sourcepub fn to_euler_angles(&self) -> (N, N, N)
👎Deprecated: This is renamed to use .euler_angles()
.
pub fn to_euler_angles(&self) -> (N, N, N)
.euler_angles()
.Converts this unit quaternion into its equivalent Euler angles.
The angles are produced in the form (roll, pitch, yaw).
sourcepub fn euler_angles(&self) -> (N, N, N)
pub fn euler_angles(&self) -> (N, N, N)
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);
sourcepub fn to_homogeneous(&self) -> MatrixN<N, U4>
pub fn to_homogeneous(&self) -> MatrixN<N, U4>
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);
source§impl<N: Real> UnitQuaternion<N>
impl<N: Real> UnitQuaternion<N>
sourcepub fn identity() -> Self
pub fn identity() -> Self
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);
sourcepub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Selfwhere
SB: Storage<N, U3>,
pub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Selfwhere
SB: Storage<N, U3>,
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());
sourcepub fn from_quaternion(q: Quaternion<N>) -> Self
pub fn from_quaternion(q: Quaternion<N>) -> Self
Creates a new unit quaternion from a quaternion.
The input quaternion will be normalized.
sourcepub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self
pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self
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);
sourcepub fn from_rotation_matrix(rotmat: &Rotation<N, U3>) -> Self
pub fn from_rotation_matrix(rotmat: &Rotation<N, U3>) -> Self
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);
sourcepub 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>,
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>,
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);
sourcepub 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>,
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>,
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);
sourcepub 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>,
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>,
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);
sourcepub 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>,
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>,
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);
sourcepub fn new_observer_frame<SB, SC>(
dir: &Vector<N, U3, SB>,
up: &Vector<N, U3, SC>
) -> Selfwhere
SB: Storage<N, U3>,
SC: Storage<N, U3>,
pub fn new_observer_frame<SB, SC>(
dir: &Vector<N, U3, SB>,
up: &Vector<N, U3, SC>
) -> Selfwhere
SB: Storage<N, U3>,
SC: Storage<N, U3>,
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::new_observer_frame(&dir, &up);
assert_relative_eq!(q * Vector3::z(), dir.normalize());
sourcepub fn look_at_rh<SB, SC>(
dir: &Vector<N, U3, SB>,
up: &Vector<N, U3, SC>
) -> Selfwhere
SB: Storage<N, U3>,
SC: Storage<N, U3>,
pub fn look_at_rh<SB, SC>(
dir: &Vector<N, U3, SB>,
up: &Vector<N, U3, SC>
) -> Selfwhere
SB: Storage<N, U3>,
SC: Storage<N, U3>,
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());
sourcepub fn look_at_lh<SB, SC>(
dir: &Vector<N, U3, SB>,
up: &Vector<N, U3, SC>
) -> Selfwhere
SB: Storage<N, U3>,
SC: Storage<N, U3>,
pub fn look_at_lh<SB, SC>(
dir: &Vector<N, U3, SB>,
up: &Vector<N, U3, SC>
) -> Selfwhere
SB: Storage<N, U3>,
SC: Storage<N, U3>,
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());
sourcepub fn new<SB>(axisangle: Vector<N, U3, SB>) -> Selfwhere
SB: Storage<N, U3>,
pub fn new<SB>(axisangle: Vector<N, U3, SB>) -> Selfwhere
SB: Storage<N, U3>,
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());
sourcepub fn new_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Selfwhere
SB: Storage<N, U3>,
pub fn new_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Selfwhere
SB: Storage<N, U3>,
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());
sourcepub fn from_scaled_axis<SB>(axisangle: Vector<N, U3, SB>) -> Selfwhere
SB: Storage<N, U3>,
pub fn from_scaled_axis<SB>(axisangle: Vector<N, U3, SB>) -> Selfwhere
SB: Storage<N, U3>,
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());
sourcepub fn from_scaled_axis_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Selfwhere
SB: Storage<N, U3>,
pub fn from_scaled_axis_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Selfwhere
SB: Storage<N, U3>,
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§
source§impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq<Unit<Quaternion<N>>> for UnitQuaternion<N>
impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq<Unit<Quaternion<N>>> for UnitQuaternion<N>
source§fn default_epsilon() -> Self::Epsilon
fn default_epsilon() -> Self::Epsilon
source§impl<N: Real> AbstractMagma<Multiplicative> for UnitQuaternion<N>
impl<N: Real> AbstractMagma<Multiplicative> for UnitQuaternion<N>
source§impl<N: Real> AbstractMonoid<Multiplicative> for UnitQuaternion<N>
impl<N: Real> AbstractMonoid<Multiplicative> for UnitQuaternion<N>
source§fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> boolwhere
Self: RelativeEq<Self>,
fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> boolwhere
Self: RelativeEq<Self>,
source§impl<N: Real> AbstractQuasigroup<Multiplicative> for UnitQuaternion<N>
impl<N: Real> AbstractQuasigroup<Multiplicative> for UnitQuaternion<N>
source§fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> boolwhere
Self: RelativeEq<Self>,
fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> boolwhere
Self: RelativeEq<Self>,
true
if latin squareness holds for the given arguments. Approximate
equality is used for verifications. Read moresource§impl<N: Real> AbstractSemigroup<Multiplicative> for UnitQuaternion<N>
impl<N: Real> AbstractSemigroup<Multiplicative> for UnitQuaternion<N>
source§fn prop_is_associative_approx(args: (Self, Self, Self)) -> boolwhere
Self: RelativeEq<Self>,
fn prop_is_associative_approx(args: (Self, Self, Self)) -> boolwhere
Self: RelativeEq<Self>,
true
if associativity holds for the given arguments. Approximate equality is used
for verifications. Read moresource§impl<N: Real> AffineTransformation<Point<N, U3>> for UnitQuaternion<N>
impl<N: Real> AffineTransformation<Point<N, U3>> for UnitQuaternion<N>
§type Rotation = Unit<Quaternion<N>>
type Rotation = Unit<Quaternion<N>>
§type NonUniformScaling = Id<Multiplicative>
type NonUniformScaling = Id<Multiplicative>
§type Translation = Id<Multiplicative>
type Translation = Id<Multiplicative>
source§fn decompose(&self) -> (Id, Self, Id, Self)
fn decompose(&self) -> (Id, Self, Id, Self)
source§fn append_translation(&self, _: &Self::Translation) -> Self
fn append_translation(&self, _: &Self::Translation) -> Self
source§fn prepend_translation(&self, _: &Self::Translation) -> Self
fn prepend_translation(&self, _: &Self::Translation) -> Self
source§fn append_rotation(&self, r: &Self::Rotation) -> Self
fn append_rotation(&self, r: &Self::Rotation) -> Self
source§fn prepend_rotation(&self, r: &Self::Rotation) -> Self
fn prepend_rotation(&self, r: &Self::Rotation) -> Self
source§fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self
fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self
source§fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self
fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self
source§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>,
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>,
source§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>,
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>,
source§impl<'a, 'b, N: Real> Div<&'b Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'a, 'b, N: Real> Div<&'b Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<'b, N: Real> Div<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'b, N: Real> Div<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§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>,
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>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn div(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
/
operation. Read moresource§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>,
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>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn div(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
/
operation. Read moresource§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>,
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>,
source§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>,
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>,
source§impl<'a, 'b, N: Real> Div<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'a, 'b, N: Real> Div<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
/
operator.source§impl<'b, N: Real> Div<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'b, N: Real> Div<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
/
operator.source§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>,
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>,
source§impl<N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'a, N: Real> Div<Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'a, N: Real> Div<Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<N: Real> Div<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<N: Real> Div<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§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>,
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>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn div(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
/
operation. Read moresource§impl<N: Real> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N: Real> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn div(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
/
operation. Read moresource§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>,
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>,
source§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>,
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>,
source§impl<'a, N: Real> Div<Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'a, N: Real> Div<Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
/
operator.source§impl<N: Real> Div<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<N: Real> Div<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
/
operator.source§impl<'b, N: Real> DivAssign<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'b, N: Real> DivAssign<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<'b, N: Real> DivAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'b, N: Real> DivAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
source§fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)
fn div_assign(&mut self, rhs: &'b UnitQuaternion<N>)
/=
operation. Read moresource§impl<N: Real> DivAssign<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<N: Real> DivAssign<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<N: Real> DivAssign<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<N: Real> DivAssign<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
source§fn div_assign(&mut self, rhs: UnitQuaternion<N>)
fn div_assign(&mut self, rhs: UnitQuaternion<N>)
/=
operation. Read moresource§impl<N: Real> Identity<Multiplicative> for UnitQuaternion<N>
impl<N: Real> Identity<Multiplicative> for UnitQuaternion<N>
source§impl<N: Real> Inverse<Multiplicative> for UnitQuaternion<N>
impl<N: Real> Inverse<Multiplicative> for UnitQuaternion<N>
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§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>,
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>,
source§impl<'a, 'b, N: Real> Mul<&'b Point<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, 'b, N: Real> Mul<&'b Point<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'b, N: Real> Mul<&'b Point<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'b, N: Real> Mul<&'b Point<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'a, 'b, N: Real> Mul<&'b Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'a, 'b, N: Real> Mul<&'b Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<'b, N: Real> Mul<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'b, N: Real> Mul<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§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>,
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>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn mul(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
*
operation. Read moresource§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>,
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>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn mul(self, right: &'b Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
*
operation. Read moresource§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>,
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>,
source§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>,
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>,
source§impl<'a, 'b, N: Real> Mul<&'b Translation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, 'b, N: Real> Mul<&'b Translation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'b, N: Real> Mul<&'b Translation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'b, N: Real> Mul<&'b Translation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§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>,
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>,
source§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>,
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>,
source§impl<'a, 'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'a, 'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
*
operator.source§impl<'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'b, N: Real> Mul<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
*
operator.source§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>,
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>,
source§impl<N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§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>,
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>,
source§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>,
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>,
source§impl<'a, N: Real> Mul<Point<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, N: Real> Mul<Point<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<N: Real> Mul<Point<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N: Real> Mul<Point<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'a, N: Real> Mul<Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'a, N: Real> Mul<Rotation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<N: Real> Mul<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<N: Real> Mul<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§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>,
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>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn mul(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
*
operation. Read moresource§impl<N: Real> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N: Real> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
fn mul(self, right: Similarity<N, U3, UnitQuaternion<N>>) -> Self::Output
*
operation. Read moresource§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>,
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>,
source§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>,
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>,
source§impl<'a, N: Real> Mul<Translation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, N: Real> Mul<Translation<N, U3>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<N: Real> Mul<Translation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N: Real> Mul<Translation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§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>,
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>,
source§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>,
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>,
source§impl<'a, N: Real> Mul<Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'a, N: Real> Mul<Unit<Quaternion<N>>> for &'a UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
*
operator.source§impl<N: Real> Mul<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<N: Real> Mul<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
§type Output = Unit<Quaternion<N>>
type Output = Unit<Quaternion<N>>
*
operator.source§impl<'b, N: Real> MulAssign<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<'b, N: Real> MulAssign<&'b Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<'b, N: Real> MulAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<'b, N: Real> MulAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
source§fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)
fn mul_assign(&mut self, rhs: &'b UnitQuaternion<N>)
*=
operation. Read moresource§impl<N: Real> MulAssign<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
impl<N: Real> MulAssign<Rotation<N, U3>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>,
source§impl<N: Real> MulAssign<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
impl<N: Real> MulAssign<Unit<Quaternion<N>>> for UnitQuaternion<N>where
DefaultAllocator: Allocator<N, U4, U1>,
source§fn mul_assign(&mut self, rhs: UnitQuaternion<N>)
fn mul_assign(&mut self, rhs: UnitQuaternion<N>)
*=
operation. Read moresource§impl<N: Real> One for UnitQuaternion<N>
impl<N: Real> One for UnitQuaternion<N>
source§impl<N: Real> ProjectiveTransformation<Point<N, U3>> for UnitQuaternion<N>
impl<N: Real> ProjectiveTransformation<Point<N, U3>> for UnitQuaternion<N>
source§impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq<Unit<Quaternion<N>>> for UnitQuaternion<N>
impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq<Unit<Quaternion<N>>> for UnitQuaternion<N>
source§fn default_max_relative() -> Self::Epsilon
fn default_max_relative() -> Self::Epsilon
source§impl<N: Real> Rotation<Point<N, U3>> for UnitQuaternion<N>
impl<N: Real> Rotation<Point<N, U3>> for UnitQuaternion<N>
source§fn powf(&self, n: N) -> Option<Self>
fn powf(&self, n: N) -> Option<Self>
n
. Read moresource§fn rotation_between(a: &Vector3<N>, b: &Vector3<N>) -> Option<Self>
fn rotation_between(a: &Vector3<N>, b: &Vector3<N>) -> Option<Self>
a
and b
equal to zero, i.e.,
b.angle(a * delta_rotation(a, b)) = 0
. If a
and b
are collinear, the computed
rotation may not be unique. Returns None
if no such simple rotation exists in the
subgroup represented by Self
. Read moresource§impl<N: Real> Similarity<Point<N, U3>> for UnitQuaternion<N>
impl<N: Real> Similarity<Point<N, U3>> for UnitQuaternion<N>
§type Scaling = Id<Multiplicative>
type Scaling = Id<Multiplicative>
source§fn translation(&self) -> Id
fn translation(&self) -> Id
source§fn translate_point(&self, pt: &E) -> E
fn translate_point(&self, pt: &E) -> E
source§fn rotate_point(&self, pt: &E) -> E
fn rotate_point(&self, pt: &E) -> E
source§fn scale_point(&self, pt: &E) -> E
fn scale_point(&self, pt: &E) -> E
source§fn rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§fn scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§fn inverse_translate_point(&self, pt: &E) -> E
fn inverse_translate_point(&self, pt: &E) -> E
source§fn inverse_rotate_point(&self, pt: &E) -> E
fn inverse_rotate_point(&self, pt: &E) -> E
source§fn inverse_scale_point(&self, pt: &E) -> E
fn inverse_scale_point(&self, pt: &E) -> E
source§fn inverse_rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn inverse_rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§fn inverse_scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn inverse_scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§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>>,
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>>,
source§fn to_superset(&self) -> Isometry<N2, U3, R>
fn to_superset(&self) -> Isometry<N2, U3, R>
self
to the equivalent element of its superset.source§fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool
fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> Self
unsafe fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for UnitQuaternion<N1>
impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for UnitQuaternion<N1>
source§fn to_superset(&self) -> Matrix4<N2>
fn to_superset(&self) -> Matrix4<N2>
self
to the equivalent element of its superset.source§fn is_in_subset(m: &Matrix4<N2>) -> bool
fn is_in_subset(m: &Matrix4<N2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(m: &Matrix4<N2>) -> Self
unsafe fn from_superset_unchecked(m: &Matrix4<N2>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1>where
N1: Real,
N2: Real + SupersetOf<N1>,
impl<N1, N2> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1>where
N1: Real,
N2: Real + SupersetOf<N1>,
source§fn to_superset(&self) -> Rotation3<N2>
fn to_superset(&self) -> Rotation3<N2>
self
to the equivalent element of its superset.source§fn is_in_subset(rot: &Rotation3<N2>) -> bool
fn is_in_subset(rot: &Rotation3<N2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(rot: &Rotation3<N2>) -> Self
unsafe fn from_superset_unchecked(rot: &Rotation3<N2>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§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>>,
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>>,
source§fn to_superset(&self) -> Similarity<N2, U3, R>
fn to_superset(&self) -> Similarity<N2, U3, R>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool
fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(sim: &Similarity<N2, U3, R>) -> Self
unsafe fn from_superset_unchecked(sim: &Similarity<N2, U3, R>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1>where
N1: Real,
N2: Real + SupersetOf<N1>,
C: SuperTCategoryOf<TAffine>,
impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1>where
N1: Real,
N2: Real + SupersetOf<N1>,
C: SuperTCategoryOf<TAffine>,
source§fn to_superset(&self) -> Transform<N2, U3, C>
fn to_superset(&self) -> Transform<N2, U3, C>
self
to the equivalent element of its superset.source§fn is_in_subset(t: &Transform<N2, U3, C>) -> bool
fn is_in_subset(t: &Transform<N2, U3, C>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(t: &Transform<N2, U3, C>) -> Self
unsafe fn from_superset_unchecked(t: &Transform<N2, U3, C>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for UnitQuaternion<N1>where
N1: Real,
N2: Real + SupersetOf<N1>,
impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for UnitQuaternion<N1>where
N1: Real,
N2: Real + SupersetOf<N1>,
source§fn to_superset(&self) -> UnitQuaternion<N2>
fn to_superset(&self) -> UnitQuaternion<N2>
self
to the equivalent element of its superset.source§fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool
fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> Self
unsafe fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> Self
self.to_superset
but without any property checks. Always succeeds.