Struct rin::math::geometry::Rotation[−][src]

#[repr(C)]
pub struct Rotation<N, D> where
    N: Scalar,
    D: DimName,
    DefaultAllocator: Allocator<N, D, D>,  { /* fields omitted */ }

A rotation matrix.

This is also known as an element of a Special Orthogonal (SO) group. The Rotation type can either represent a 2D or 3D rotation, represented as a matrix. For a rotation based on quaternions, see UnitQuaternion instead.

Note that instead of using the Rotation type in your code directly, you should use one of its aliases: Rotation2, or Rotation3. Though keep in mind that all the documentation of all the methods of these aliases will also appears on this page.

Construction

Identity identity
From a 2D rotation angle new…
From an existing 2D matrix or rotations from_matrix, rotation_between, powf…
From a 3D axis and/or angles new, from_euler_angles, from_axis_angle…
From a 3D eye position and target point look_at, look_at_lh, rotation_between…
From an existing 3D matrix or rotations from_matrix, rotation_between, powf…

Transformation and composition

Note that transforming vectors and points can be done by multiplication, e.g., rotation * point. Composing an rotation with another transformation can also be done by multiplication or division.

3D axis and angle extraction angle, euler_angles, scaled_axis, angle_to…
2D angle extraction angle, angle_to…
Transformation of a vector or a point transform_vector, inverse_transform_point…
Transposition and inversion transpose, inverse…
Interpolation slerp…

Conversion

Conversion to a matrix matrix, to_homogeneous…

Implementations

`impl<N, D> Rotation<N, D> where N: Scalar, D: DimName, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn from_matrix_unchecked( matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> ) -> Rotation<N, D>`[src]

Creates a new rotation from the given square matrix.

The matrix squareness is checked but not its orthonormality.

Example

let mat = Matrix3::new(0.8660254, -0.5,      0.0,
                       0.5,       0.8660254, 0.0,
                       0.0,       0.0,       1.0);
let rot = Rotation3::from_matrix_unchecked(mat);

assert_eq!(*rot.matrix(), mat);


let mat = Matrix2::new(0.8660254, -0.5,
                       0.5,       0.8660254);
let rot = Rotation2::from_matrix_unchecked(mat);

assert_eq!(*rot.matrix(), mat);

`impl<N, D> Rotation<N, D> where N: Scalar, D: DimName, DefaultAllocator: Allocator<N, D, D>,` [src]

Conversion to a matrix

`pub fn matrix( &self ) -> &Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

A reference to the underlying matrix representation of this rotation.

Example

let rot = Rotation3::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);
assert_eq!(*rot.matrix(), expected);


let rot = Rotation2::new(f32::consts::FRAC_PI_6);
let expected = Matrix2::new(0.8660254, -0.5,
                            0.5,       0.8660254);
assert_eq!(*rot.matrix(), expected);

`pub unsafe fn matrix_mut( &mut self ) -> &mut Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

👎 Deprecated:

Use .matrix_mut_unchecked() instead.

A mutable reference to the underlying matrix representation of this rotation.

`pub fn matrix_mut_unchecked( &mut self ) -> &mut Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

A mutable reference to the underlying matrix representation of this rotation.

This is suffixed by “_unchecked” because this allows the user to replace the matrix by another one that is non-square, non-inversible, or non-orthonormal. If one of those properties is broken, subsequent method calls may be UB.

`pub fn into_inner( self ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

Unwraps the underlying matrix.

Example

let rot = Rotation3::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let mat = rot.into_inner();
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);
assert_eq!(mat, expected);


let rot = Rotation2::new(f32::consts::FRAC_PI_6);
let mat = rot.into_inner();
let expected = Matrix2::new(0.8660254, -0.5,
                            0.5,       0.8660254);
assert_eq!(mat, expected);

`pub fn unwrap( self ) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>`[src]

👎 Deprecated:

use .into_inner() instead

Unwraps the underlying matrix. Deprecated: Use Rotation::into_inner instead.

`pub fn to_homogeneous( &self ) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> where N: Zero + One, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,` [src]

Converts this rotation into its equivalent homogeneous transformation matrix.

This is the same as self.into().

Example

let rot = Rotation3::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_eq!(rot.to_homogeneous(), expected);


let rot = Rotation2::new(f32::consts::FRAC_PI_6);
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);
assert_eq!(rot.to_homogeneous(), expected);

`impl<N, D> Rotation<N, D> where N: Scalar, D: DimName, DefaultAllocator: Allocator<N, D, D>,` [src]

Transposition and inversion

`#[must_use = "Did you mean to use transpose_mut()?"] pub fn transpose(&self) -> Rotation<N, D>`[src]

Transposes self.

Same as .inverse() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let tr_rot = rot.transpose();
assert_relative_eq!(rot * tr_rot, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let tr_rot = rot.transpose();
assert_relative_eq!(rot * tr_rot, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation2::identity(), epsilon = 1.0e-6);

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

Inverts self.

Same as .transpose() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let inv = rot.inverse();
assert_relative_eq!(rot * inv, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let inv = rot.inverse();
assert_relative_eq!(rot * inv, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation2::identity(), epsilon = 1.0e-6);

`pub fn transpose_mut(&mut self)`[src]

Transposes self in-place.

Same as .inverse_mut() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let mut tr_rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
tr_rot.transpose_mut();

assert_relative_eq!(rot * tr_rot, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let mut tr_rot = Rotation2::new(1.2);
tr_rot.transpose_mut();

assert_relative_eq!(rot * tr_rot, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation2::identity(), epsilon = 1.0e-6);

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

Inverts self in-place.

Same as .transpose_mut() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let mut inv = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
inv.inverse_mut();

assert_relative_eq!(rot * inv, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let mut inv = Rotation2::new(1.2);
inv.inverse_mut();

assert_relative_eq!(rot * inv, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation2::identity(), epsilon = 1.0e-6);

`impl<N, D> Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

Transformation of a vector or a point

`pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>`[src]

Rotate the given point.

This is the same as the multiplication self * pt.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_point = rot.transform_point(&Point3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);

`pub fn transform_vector( &self, v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>`[src]

Rotate the given vector.

This is the same as the multiplication self * v.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_vector = rot.transform_vector(&Vector3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);

`pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>`[src]

Rotate the given point by the inverse of this rotation. This may be cheaper than inverting the rotation and then transforming the given point.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_point = rot.inverse_transform_point(&Point3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);

`pub fn inverse_transform_vector( &self, v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>`[src]

Rotate the given vector by the inverse of this rotation. This may be cheaper than inverting the rotation and then transforming the given vector.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_vector = rot.inverse_transform_vector(&Vector3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);

`pub fn inverse_transform_unit_vector( &self, v: &Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> ) -> Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>`[src]

Rotate the given vector by the inverse of this rotation. This may be cheaper than inverting the rotation and then transforming the given vector.

Example

let rot = Rotation3::new(Vector3::z() * f32::consts::FRAC_PI_2);
let transformed_vector = rot.inverse_transform_unit_vector(&Vector3::x_axis());

assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6);

`impl<N, D> Rotation<N, D> where N: Scalar + Zero + One, D: DimName, DefaultAllocator: Allocator<N, D, D>,` [src]

Identity

`pub fn identity() -> Rotation<N, D>`[src]

Creates a new square identity rotation of the given dimension.

Example

let rot1 = Quaternion::identity();
let rot2 = Quaternion::new(1.0, 2.0, 3.0, 4.0);

assert_eq!(rot1 * rot2, rot2);
assert_eq!(rot2 * rot1, rot2);

`impl<N> Rotation<N, U2> where N: SimdRealField,` [src]

Interpolation

`pub fn slerp(&self, other: &Rotation<N, U2>, t: N) -> Rotation<N, U2> where <N as SimdValue>::Element: SimdRealField,` [src]

Spherical linear interpolation between two rotation matrices.

Examples:


let rot1 = Rotation2::new(std::f32::consts::FRAC_PI_4);
let rot2 = Rotation2::new(-std::f32::consts::PI);

let rot = rot1.slerp(&rot2, 1.0 / 3.0);

assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2);

`impl<N> Rotation<N, U3> where N: SimdRealField,` [src]

`pub fn slerp(&self, other: &Rotation<N, U3>, t: N) -> Rotation<N, U3> where N: RealField,` [src]

Spherical linear interpolation between two rotation matrices.

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

Examples:


let q1 = Rotation3::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = Rotation3::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);

let q = q1.slerp(&q2, 1.0 / 3.0);

assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

`pub fn try_slerp( &self, other: &Rotation<N, U3>, t: N, epsilon: N ) -> Option<Rotation<N, U3>> where N: RealField,` [src]

Computes the spherical linear interpolation between two rotation matrices or returns None if both rotations are approximately 180 degrees apart (in which case the interpolation is not well-defined).

Arguments

self: the first rotation to interpolate from.
other: the second rotation 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 rotations must be to return None.

`impl<N> Rotation<N, U2> where N: SimdRealField,` [src]

Construction from a 2D rotation angle

`pub fn new(angle: N) -> Rotation<N, U2>`[src]

Builds a 2 dimensional rotation matrix from an angle in radian.

Example

let rot = Rotation2::new(f32::consts::FRAC_PI_2);

assert_relative_eq!(rot * Point2::new(3.0, 4.0), Point2::new(-4.0, 3.0));

`pub fn from_scaled_axis<SB>(axisangle: Matrix<N, U1, U1, SB>) -> Rotation<N, U2> where SB: Storage<N, U1, U1>,` [src]

Builds a 2 dimensional rotation matrix from an angle in radian wrapped in a 1-dimensional vector.

This is generally used in the context of generic programming. Using the ::new(angle) method instead is more common.

`impl<N> Rotation<N, U2> where N: SimdRealField,` [src]

Construction from an existing 2D matrix or rotations

`pub fn from_matrix( m: &Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> ) -> Rotation<N, U2> where N: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This is an iterative method. See .from_matrix_eps to provide mover convergence parameters and starting solution. This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

`pub fn from_matrix_eps( m: &Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>, eps: N, max_iter: usize, guess: Rotation<N, U2> ) -> Rotation<N, U2> where N: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

Parameters

m: the matrix from which the rotational part is to be extracted.
eps: the angular errors tolerated between the current rotation and the optimal one.
max_iter: the maximum number of iterations. Loops indefinitely until convergence if set to 0.
guess: an estimate of the solution. Convergence will be significantly faster if an initial solution close to the actual solution is provided. Can be set to Rotation2::identity() if no other guesses come to mind.

`pub fn rotation_between<SB, SC>( a: &Matrix<N, U2, U1, SB>, b: &Matrix<N, U2, U1, SC> ) -> Rotation<N, U2> where N: RealField, SB: Storage<N, U2, U1>, SC: Storage<N, U2, U1>,` [src]

The rotation matrix required to align a and b but with its angle.

This is the rotation R such that (R * a).angle(b) == 0 && (R * a).dot(b).is_positive().

Example

let a = Vector2::new(1.0, 2.0);
let b = Vector2::new(2.0, 1.0);
let rot = Rotation2::rotation_between(&a, &b);
assert_relative_eq!(rot * a, b);
assert_relative_eq!(rot.inverse() * b, a);

`pub fn scaled_rotation_between<SB, SC>( a: &Matrix<N, U2, U1, SB>, b: &Matrix<N, U2, U1, SC>, s: N ) -> Rotation<N, U2> where N: RealField, SB: Storage<N, U2, U1>, SC: Storage<N, U2, U1>,` [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 = Vector2::new(1.0, 2.0);
let b = Vector2::new(2.0, 1.0);
let rot2 = Rotation2::scaled_rotation_between(&a, &b, 0.2);
let rot5 = Rotation2::scaled_rotation_between(&a, &b, 0.5);
assert_relative_eq!(rot2 * rot2 * rot2 * rot2 * rot2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(rot5 * rot5 * a, b, epsilon = 1.0e-6);

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

The rotation matrix needed to make self and other coincide.

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

Example

let rot1 = Rotation2::new(0.1);
let rot2 = Rotation2::new(1.7);
let rot_to = rot1.rotation_to(&rot2);

assert_relative_eq!(rot_to * rot1, rot2);
assert_relative_eq!(rot_to.inverse() * rot2, rot1);

`pub fn renormalize(&mut self) where N: RealField,` [src]

Ensure this rotation is an orthonormal rotation matrix. This is useful when repeated computations might cause the matrix from progressively not being orthonormal anymore.

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

Raise the quaternion to a given floating power, i.e., returns the rotation with the angle of self multiplied by n.

Example

let rot = Rotation2::new(0.78);
let pow = rot.powf(2.0);
assert_relative_eq!(pow.angle(), 2.0 * 0.78);

`impl<N> Rotation<N, U2> where N: SimdRealField,` [src]

2D angle extraction

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

The rotation angle.

Example

let rot = Rotation2::new(1.78);
assert_relative_eq!(rot.angle(), 1.78);

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

The rotation angle needed to make self and other coincide.

Example

let rot1 = Rotation2::new(0.1);
let rot2 = Rotation2::new(1.7);
assert_relative_eq!(rot1.angle_to(&rot2), 1.6);

`pub fn scaled_axis( &self ) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>`[src]

The rotation angle returned as a 1-dimensional vector.

This is generally used in the context of generic programming. Using the .angle() method instead is more common.

`impl<N> Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

Construction from a 3D axis and/or angles

`pub fn new<SB>(axisangle: Matrix<N, U3, U1, SB>) -> Rotation<N, U3> where SB: Storage<N, U3, U1>,` [src]

Builds a 3 dimensional rotation matrix from an axis and an angle.

Arguments

axisangle - A vector representing the rotation. Its magnitude is the amount of rotation in radian. Its direction is the axis of 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 rot = Rotation3::new(axisangle);

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

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

`pub fn from_scaled_axis<SB>(axisangle: Matrix<N, U3, U1, SB>) -> Rotation<N, U3> where SB: Storage<N, U3, U1>,` [src]

Builds a 3D rotation matrix from an axis scaled by the rotation angle.

This is the 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 rot = Rotation3::new(axisangle);

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

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

`pub fn from_axis_angle<SB>( axis: &Unit<Matrix<N, U3, U1, SB>>, angle: N ) -> Rotation<N, U3> where SB: Storage<N, U3, U1>,` [src]

Builds a 3D rotation matrix from an axis and a 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 rot = Rotation3::from_axis_angle(&axis, angle);

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

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

`pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Rotation<N, U3>`[src]

Creates a new rotation from Euler angles.

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

Example

let rot = Rotation3::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);

`impl<N> Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

Construction from a 3D eye position and target point

`pub fn face_towards<SB, SC>( dir: &Matrix<N, U3, U1, SB>, up: &Matrix<N, U3, U1, SC> ) -> Rotation<N, U3> where SB: Storage<N, U3, U1>, SC: Storage<N, U3, U1>,` [src]

Creates a rotation 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, that is, direction the matrix z axis will be aligned with.
up - The vertical direction. 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 rot = Rotation3::face_towards(&dir, &up);
assert_relative_eq!(rot * Vector3::z(), dir.normalize());

`pub fn new_observer_frames<SB, SC>( dir: &Matrix<N, U3, U1, SB>, up: &Matrix<N, U3, U1, SC> ) -> Rotation<N, U3> where SB: Storage<N, U3, U1>, SC: Storage<N, U3, U1>,` [src]

👎 Deprecated:

renamed to face_towards

Deprecated: Use [Rotation3::face_towards] instead.

`pub fn look_at_rh<SB, SC>( dir: &Matrix<N, U3, U1, SB>, up: &Matrix<N, U3, U1, SC> ) -> Rotation<N, U3> where SB: Storage<N, U3, U1>, SC: Storage<N, U3, U1>,` [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 direction toward which the camera looks.
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 rot = Rotation3::look_at_rh(&dir, &up);
assert_relative_eq!(rot * dir.normalize(), -Vector3::z());

`pub fn look_at_lh<SB, SC>( dir: &Matrix<N, U3, U1, SB>, up: &Matrix<N, U3, U1, SC> ) -> Rotation<N, U3> where SB: Storage<N, U3, U1>, SC: Storage<N, U3, U1>,` [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 direction toward which the camera looks.
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 rot = Rotation3::look_at_lh(&dir, &up);
assert_relative_eq!(rot * dir.normalize(), Vector3::z());

`impl<N> Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

Construction from an existing 3D matrix or rotations

`pub fn rotation_between<SB, SC>( a: &Matrix<N, U3, U1, SB>, b: &Matrix<N, U3, U1, SC> ) -> Option<Rotation<N, U3>> where N: RealField, SB: Storage<N, U3, U1>, SC: Storage<N, U3, U1>,` [src]

The rotation matrix required to align a and b but with its angle.

This is the rotation R such that (R * a).angle(b) == 0 && (R * a).dot(b).is_positive().

Example

let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let rot = Rotation3::rotation_between(&a, &b).unwrap();
assert_relative_eq!(rot * a, b, epsilon = 1.0e-6);
assert_relative_eq!(rot.inverse() * b, a, epsilon = 1.0e-6);

`pub fn scaled_rotation_between<SB, SC>( a: &Matrix<N, U3, U1, SB>, b: &Matrix<N, U3, U1, SC>, n: N ) -> Option<Rotation<N, U3>> where N: RealField, SB: Storage<N, U3, U1>, SC: Storage<N, U3, U1>,` [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 rot2 = Rotation3::scaled_rotation_between(&a, &b, 0.2).unwrap();
let rot5 = Rotation3::scaled_rotation_between(&a, &b, 0.5).unwrap();
assert_relative_eq!(rot2 * rot2 * rot2 * rot2 * rot2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(rot5 * rot5 * a, b, epsilon = 1.0e-6);

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

The rotation matrix needed to make self and other coincide.

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

Example

let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = Rotation3::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 powf(&self, n: N) -> Rotation<N, U3> where N: RealField,` [src]

Raise the quaternion to a given floating power, i.e., returns the rotation with the same axis as self and an angle equal to self.angle() multiplied by n.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = Rotation3::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 from_matrix( m: &Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> ) -> Rotation<N, U3> where N: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This is an iterative method. See .from_matrix_eps to provide mover convergence parameters and starting solution. This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

`pub fn from_matrix_eps( m: &Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>, eps: N, max_iter: usize, guess: Rotation<N, U3> ) -> Rotation<N, U3> where N: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

Parameters

m: the matrix from which the rotational part is to be extracted.
eps: the angular errors tolerated between the current rotation and the optimal one.
max_iter: the maximum number of iterations. Loops indefinitely until convergence if set to 0.
guess: a guess of the solution. Convergence will be significantly faster if an initial solution close to the actual solution is provided. Can be set to Rotation3::identity() if no other guesses come to mind.

`pub fn renormalize(&mut self) where N: RealField,` [src]

Ensure this rotation is an orthonormal rotation matrix. This is useful when repeated computations might cause the matrix from progressively not being orthonormal anymore.

`impl<N> Rotation<N, U3> where N: SimdRealField,` [src]

3D axis and angle extraction

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

The rotation angle in [0; pi].

Example

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

`pub fn axis( &self ) -> Option<Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>> where N: RealField,` [src]

The rotation axis. Returns None if the rotation angle is zero or PI.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = Rotation3::from_axis_angle(&axis, angle);
assert_relative_eq!(rot.axis().unwrap(), axis);

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

`pub fn scaled_axis( &self ) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where N: RealField,` [src]

The rotation axis multiplied by the rotation angle.

Example

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

`pub fn axis_angle( &self ) -> Option<(Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>, N)> where N: RealField,` [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 = Rotation3::from_axis_angle(&axis, angle);
let axis_angle = rot.axis_angle().unwrap();
assert_relative_eq!(axis_angle.0, axis);
assert_relative_eq!(axis_angle.1, angle);

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

`pub fn angle_to(&self, other: &Rotation<N, U3>) -> N where <N as SimdValue>::Element: SimdRealField,` [src]

The rotation angle needed to make self and other coincide.

Example

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

`pub fn to_euler_angles(&self) -> (N, N, N) where N: RealField,` [src]

👎 Deprecated:

This is renamed to use .euler_angles().

Creates Euler angles from a rotation.

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

`pub fn euler_angles(&self) -> (N, N, N) where N: RealField,` [src]

Euler angles corresponding to this rotation from a rotation.

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

Example

let rot = Rotation3::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);

Trait Implementations

`impl<N, D> AbsDiffEq<Rotation<N, D>> for Rotation<N, D> where N: Scalar + AbsDiffEq<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, <N as AbsDiffEq<N>>::Epsilon: Copy,` [src]

`type Epsilon = <N as AbsDiffEq<N>>::Epsilon`

Used for specifying relative comparisons.

`pub fn default_epsilon( ) -> <Rotation<N, D> as AbsDiffEq<Rotation<N, D>>>::Epsilon`[src]

`pub fn abs_diff_eq( &self, other: &Rotation<N, D>, epsilon: <Rotation<N, D> as AbsDiffEq<Rotation<N, D>>>::Epsilon ) -> bool`[src]

`pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool`[src]

`impl<N, D> AbstractRotation<N, D> for Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn identity() -> Rotation<N, D>`[src]

`pub fn inverse(&self) -> Rotation<N, D>`[src]

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

`pub fn transform_vector( &self, v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where DefaultAllocator: Allocator<N, D, U1>,` [src]

`pub fn transform_point(&self, p: &Point<N, D>) -> Point<N, D> where DefaultAllocator: Allocator<N, D, U1>,` [src]

`pub fn inverse_transform_vector( &self, v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> ) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where DefaultAllocator: Allocator<N, D, U1>,` [src]

`pub fn inverse_transform_unit_vector( &self, v: &Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> ) -> Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> where DefaultAllocator: Allocator<N, D, U1>,` [src]

`pub fn inverse_transform_point(&self, p: &Point<N, D>) -> Point<N, D> where DefaultAllocator: Allocator<N, D, U1>,` [src]

`impl<N, D> Clone for Rotation<N, D> where N: Scalar, D: DimName, DefaultAllocator: Allocator<N, D, D>, <DefaultAllocator as Allocator<N, D, D>>::Buffer: Clone,` [src]

`pub fn clone(&self) -> Rotation<N, D>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

`impl<N, D> Debug for Rotation<N, D> where N: Debug + Scalar, D: Debug + DimName, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'a, N, D> Deserialize<'a> for Rotation<N, D> where N: Scalar, D: DimName, DefaultAllocator: Allocator<N, D, D>, <DefaultAllocator as Allocator<N, D, D>>::Buffer: Deserialize<'a>,` [src]

`pub fn deserialize<Des>( deserializer: Des ) -> Result<Rotation<N, D>, <Des as Deserializer<'a>>::Error> where Des: Deserializer<'a>,` [src]

`impl<N, D> Display for Rotation<N, D> where N: RealField + Display, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<usize, D, D>,` [src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'a, 'b, N, D> Div<&'b Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Isometry<N, D, Rotation<N, D>> ) -> <&'a Rotation<N, D> as Div<&'b Isometry<N, D, Rotation<N, D>>>>::Output`[src]

`impl<'b, N, D> Div<&'b Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Isometry<N, D, Rotation<N, D>> ) -> <Rotation<N, D> as Div<&'b Isometry<N, D, Rotation<N, D>>>>::Output`[src]

`impl<'a, 'b, N, D> Div<&'b Rotation<N, D>> for &'a Isometry<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, D> ) -> <&'a Isometry<N, D, Rotation<N, D>> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'a, 'b, N, D> Div<&'b Rotation<N, D>> for &'a Rotation<N, D> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`type Output = Rotation<N, D>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Rotation<N, D> ) -> <&'a Rotation<N, D> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'b, N, D, C> Div<&'b Rotation<N, D>> for Transform<N, D, C> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, D>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, D> ) -> <Transform<N, D, C> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'b, N, D> Div<&'b Rotation<N, D>> for Rotation<N, D> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`type Output = Rotation<N, D>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Rotation<N, D> ) -> <Rotation<N, D> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'a, 'b, N, D, C> Div<&'b Rotation<N, D>> for &'a Transform<N, D, C> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, D>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, D> ) -> <&'a Transform<N, D, C> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'a, 'b, N, D> Div<&'b Rotation<N, D>> for &'a Similarity<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, D> ) -> <&'a Similarity<N, D, Rotation<N, D>> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'b, N, D> Div<&'b Rotation<N, D>> for Similarity<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, D> ) -> <Similarity<N, D, Rotation<N, D>> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'b, N, D> Div<&'b Rotation<N, D>> for Isometry<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, D> ) -> <Isometry<N, D, Rotation<N, D>> as Div<&'b Rotation<N, D>>>::Output`[src]

`impl<'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, R1: Dim, SA: Storage<N, R1, C1>, DefaultAllocator: Allocator<N, R1, C1>, DefaultAllocator: Allocator<N, D2, D2>, DefaultAllocator: Allocator<N, R1, D2>, DefaultAllocator: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,` [src]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Rotation<N, D2> ) -> <Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output`[src]

`impl<'a, 'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, R1: Dim, SA: Storage<N, R1, C1>, DefaultAllocator: Allocator<N, R1, C1>, DefaultAllocator: Allocator<N, D2, D2>, DefaultAllocator: Allocator<N, R1, D2>, DefaultAllocator: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,` [src]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Rotation<N, D2> ) -> <&'a Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output`[src]

`impl<'a, 'b, N> Div<&'b Rotation<N, U2>> for &'a Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, U2> ) -> <&'a Unit<Complex<N>> as Div<&'b Rotation<N, U2>>>::Output`[src]

`impl<'b, N> Div<&'b Rotation<N, U2>> for Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, U2> ) -> <Unit<Complex<N>> as Div<&'b Rotation<N, U2>>>::Output`[src]

`impl<'a, 'b, N> Div<&'b Rotation<N, U3>> for &'a Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U4, U1>, DefaultAllocator: Allocator<N, U3, U3>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, U3> ) -> <&'a Unit<Quaternion<N>> as Div<&'b Rotation<N, U3>>>::Output`[src]

`impl<'b, N> Div<&'b Rotation<N, U3>> for Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U4, U1>, DefaultAllocator: Allocator<N, U3, U3>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Rotation<N, U3> ) -> <Unit<Quaternion<N>> as Div<&'b Rotation<N, U3>>>::Output`[src]

`impl<'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Similarity<N, D, Rotation<N, D>> ) -> <Rotation<N, D> as Div<&'b Similarity<N, D, Rotation<N, D>>>>::Output`[src]

`impl<'a, 'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: &'b Similarity<N, D, Rotation<N, D>> ) -> <&'a Rotation<N, D> as Div<&'b Similarity<N, D, Rotation<N, D>>>>::Output`[src]

`impl<'b, N, D, C> Div<&'b Transform<N, D, C>> for Rotation<N, D> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Transform<N, D, C> ) -> <Rotation<N, D> as Div<&'b Transform<N, D, C>>>::Output`[src]

`impl<'a, 'b, N, D, C> Div<&'b Transform<N, D, C>> for &'a Rotation<N, D> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Transform<N, D, C> ) -> <&'a Rotation<N, D> as Div<&'b Transform<N, D, C>>>::Output`[src]

`impl<'b, N> Div<&'b Unit<Complex<N>>> for Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Unit<Complex<N>> ) -> <Rotation<N, U2> as Div<&'b Unit<Complex<N>>>>::Output`[src]

`impl<'a, 'b, N> Div<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Unit<Complex<N>> ) -> <&'a Rotation<N, U2> as Div<&'b Unit<Complex<N>>>>::Output`[src]

`impl<'b, N> Div<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U3, U3>, DefaultAllocator: Allocator<N, U4, U1>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Unit<Quaternion<N>> ) -> <Rotation<N, U3> as Div<&'b Unit<Quaternion<N>>>>::Output`[src]

`impl<'a, 'b, N> Div<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U3, U3>, DefaultAllocator: Allocator<N, U4, U1>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: &'b Unit<Quaternion<N>> ) -> <&'a Rotation<N, U3> as Div<&'b Unit<Quaternion<N>>>>::Output`[src]

`impl<N, D> Div<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: Isometry<N, D, Rotation<N, D>> ) -> <Rotation<N, D> as Div<Isometry<N, D, Rotation<N, D>>>>::Output`[src]

`impl<'a, N, D> Div<Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: Isometry<N, D, Rotation<N, D>> ) -> <&'a Rotation<N, D> as Div<Isometry<N, D, Rotation<N, D>>>>::Output`[src]

`impl<N, D> Div<Rotation<N, D>> for Rotation<N, D> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`type Output = Rotation<N, D>`

The resulting type after applying the / operator.

`pub fn div( self, right: Rotation<N, D> ) -> <Rotation<N, D> as Div<Rotation<N, D>>>::Output`[src]

`impl<'a, N, D> Div<Rotation<N, D>> for &'a Rotation<N, D> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`type Output = Rotation<N, D>`

The resulting type after applying the / operator.

`pub fn div( self, right: Rotation<N, D> ) -> <&'a Rotation<N, D> as Div<Rotation<N, D>>>::Output`[src]

`impl<N, D> Div<Rotation<N, D>> for Isometry<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, D> ) -> <Isometry<N, D, Rotation<N, D>> as Div<Rotation<N, D>>>::Output`[src]

`impl<'a, N, D> Div<Rotation<N, D>> for &'a Isometry<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, D> ) -> <&'a Isometry<N, D, Rotation<N, D>> as Div<Rotation<N, D>>>::Output`[src]

`impl<'a, N, D> Div<Rotation<N, D>> for &'a Similarity<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, D> ) -> <&'a Similarity<N, D, Rotation<N, D>> as Div<Rotation<N, D>>>::Output`[src]

`impl<N, D> Div<Rotation<N, D>> for Similarity<N, D, Rotation<N, D>> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, D> ) -> <Similarity<N, D, Rotation<N, D>> as Div<Rotation<N, D>>>::Output`[src]

`impl<N, D, C> Div<Rotation<N, D>> for Transform<N, D, C> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, D>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, D> ) -> <Transform<N, D, C> as Div<Rotation<N, D>>>::Output`[src]

`impl<'a, N, D, C> Div<Rotation<N, D>> for &'a Transform<N, D, C> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, D>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, D> ) -> <&'a Transform<N, D, C> as Div<Rotation<N, D>>>::Output`[src]

`impl<N, R1, C1, D2, SA> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, R1: Dim, SA: Storage<N, R1, C1>, DefaultAllocator: Allocator<N, R1, C1>, DefaultAllocator: Allocator<N, D2, D2>, DefaultAllocator: Allocator<N, R1, D2>, DefaultAllocator: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,` [src]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: Rotation<N, D2> ) -> <Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output`[src]

`impl<'a, N, R1, C1, D2, SA> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D2: DimName, C1: Dim, R1: Dim, SA: Storage<N, R1, C1>, DefaultAllocator: Allocator<N, R1, C1>, DefaultAllocator: Allocator<N, D2, D2>, DefaultAllocator: Allocator<N, R1, D2>, DefaultAllocator: Allocator<N, R1, D2>, ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,` [src]

`type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>`

The resulting type after applying the / operator.

`pub fn div( self, right: Rotation<N, D2> ) -> <&'a Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output`[src]

`impl<N> Div<Rotation<N, U2>> for Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, U2> ) -> <Unit<Complex<N>> as Div<Rotation<N, U2>>>::Output`[src]

`impl<'a, N> Div<Rotation<N, U2>> for &'a Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, U2> ) -> <&'a Unit<Complex<N>> as Div<Rotation<N, U2>>>::Output`[src]

`impl<'a, N> Div<Rotation<N, U3>> for &'a Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U4, U1>, DefaultAllocator: Allocator<N, U3, U3>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, U3> ) -> <&'a Unit<Quaternion<N>> as Div<Rotation<N, U3>>>::Output`[src]

`impl<N> Div<Rotation<N, U3>> for Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U4, U1>, DefaultAllocator: Allocator<N, U3, U3>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Rotation<N, U3> ) -> <Unit<Quaternion<N>> as Div<Rotation<N, U3>>>::Output`[src]

`impl<'a, N, D> Div<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: Similarity<N, D, Rotation<N, D>> ) -> <&'a Rotation<N, D> as Div<Similarity<N, D, Rotation<N, D>>>>::Output`[src]

`impl<N, D> Div<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D> where N: SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, U1>,` [src]

`type Output = Similarity<N, D, Rotation<N, D>>`

The resulting type after applying the / operator.

`pub fn div( self, right: Similarity<N, D, Rotation<N, D>> ) -> <Rotation<N, D> as Div<Similarity<N, D, Rotation<N, D>>>>::Output`[src]

`impl<'a, N, D, C> Div<Transform<N, D, C>> for &'a Rotation<N, D> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Transform<N, D, C> ) -> <&'a Rotation<N, D> as Div<Transform<N, D, C>>>::Output`[src]

`impl<N, D, C> Div<Transform<N, D, C>> for Rotation<N, D> where C: TCategoryMul<TAffine>, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,` [src]

`type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Transform<N, D, C> ) -> <Rotation<N, D> as Div<Transform<N, D, C>>>::Output`[src]

`impl<'a, N> Div<Unit<Complex<N>>> for &'a Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Unit<Complex<N>> ) -> <&'a Rotation<N, U2> as Div<Unit<Complex<N>>>>::Output`[src]

`impl<N> Div<Unit<Complex<N>>> for Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`type Output = Unit<Complex<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Unit<Complex<N>> ) -> <Rotation<N, U2> as Div<Unit<Complex<N>>>>::Output`[src]

`impl<N> Div<Unit<Quaternion<N>>> for Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U3, U3>, DefaultAllocator: Allocator<N, U4, U1>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Unit<Quaternion<N>> ) -> <Rotation<N, U3> as Div<Unit<Quaternion<N>>>>::Output`[src]

`impl<'a, N> Div<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U3, U3>, DefaultAllocator: Allocator<N, U4, U1>,` [src]

`type Output = Unit<Quaternion<N>>`

The resulting type after applying the / operator.

`pub fn div( self, rhs: Unit<Quaternion<N>> ) -> <&'a Rotation<N, U3> as Div<Unit<Quaternion<N>>>>::Output`[src]

`impl<'b, N, R1, C1> DivAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, C1: DimName, R1: DimName, DefaultAllocator: Allocator<N, R1, C1>, DefaultAllocator: Allocator<N, C1, C1>,` [src]

`pub fn div_assign(&mut self, right: &'b Rotation<N, C1>)`[src]

`impl<'b, N, D, C> DivAssign<&'b Rotation<N, D>> for Transform<N, D, C> where C: TCategory, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, rhs: &'b Rotation<N, D>)`[src]

`impl<'b, N, D> DivAssign<&'b Rotation<N, D>> for Isometry<N, D, Rotation<N, D>> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, rhs: &'b Rotation<N, D>)`[src]

`impl<'b, N, D> DivAssign<&'b Rotation<N, D>> for Similarity<N, D, Rotation<N, D>> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, rhs: &'b Rotation<N, D>)`[src]

`impl<'b, N, D> DivAssign<&'b Rotation<N, D>> for Rotation<N, D> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, right: &'b Rotation<N, D>)`[src]

`impl<'b, N> DivAssign<&'b Rotation<N, U2>> for Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`pub fn div_assign(&mut self, rhs: &'b Rotation<N, U2>)`[src]

`impl<'b, N> DivAssign<&'b Rotation<N, U3>> for Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U4, U1>, DefaultAllocator: Allocator<N, U3, U3>,` [src]

`pub fn div_assign(&mut self, rhs: &'b Rotation<N, U3>)`[src]

`impl<'b, N> DivAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`pub fn div_assign(&mut self, rhs: &'b Unit<Complex<N>>)`[src]

`impl<N, R1, C1> DivAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, C1: DimName, R1: DimName, DefaultAllocator: Allocator<N, R1, C1>, DefaultAllocator: Allocator<N, C1, C1>,` [src]

`pub fn div_assign(&mut self, right: Rotation<N, C1>)`[src]

`impl<N, D> DivAssign<Rotation<N, D>> for Similarity<N, D, Rotation<N, D>> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, rhs: Rotation<N, D>)`[src]

`impl<N, D> DivAssign<Rotation<N, D>> for Isometry<N, D, Rotation<N, D>> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + SimdRealField, D: DimName, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, D, U1>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, rhs: Rotation<N, D>)`[src]

`impl<N, D> DivAssign<Rotation<N, D>> for Rotation<N, D> where N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>, D: DimName, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, right: Rotation<N, D>)`[src]

`impl<N, D, C> DivAssign<Rotation<N, D>> for Transform<N, D, C> where C: TCategory, N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField, D: DimNameAdd<U1>, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N, D, D>,` [src]

`pub fn div_assign(&mut self, rhs: Rotation<N, D>)`[src]

`impl<N> DivAssign<Rotation<N, U2>> for Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`pub fn div_assign(&mut self, rhs: Rotation<N, U2>)`[src]

`impl<N> DivAssign<Rotation<N, U3>> for Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U4, U1>, DefaultAllocator: Allocator<N, U3, U3>,` [src]

`pub fn div_assign(&mut self, rhs: Rotation<N, U3>)`[src]

`impl<N> DivAssign<Unit<Complex<N>>> for Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField, DefaultAllocator: Allocator<N, U2, U2>,` [src]

`pub fn div_assign(&mut self, rhs: Unit<Complex<N>>)`[src]

`impl<'a> From<&'a Rotation<f32, U2>> for Model`[src]

`pub fn from(r: &Rotation<f32, U2>) -> Model`[src]

`impl<'a> From<&'a Rotation<f32, U3>> for Model`[src]

`pub fn from(r: &Rotation<f32, U3>) -> Model`[src]

`impl<N, D> From<[Rotation<<N as SimdValue>::Element, D>; 16]> for Rotation<N, D> where N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 16]>, D: DimName, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: Copy, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<<N as SimdValue>::Element, D, D>,` [src]

`pub fn from(arr: [Rotation<<N as SimdValue>::Element, D>; 16]) -> Rotation<N, D>`[src]

`impl<N, D> From<[Rotation<<N as SimdValue>::Element, D>; 2]> for Rotation<N, D> where N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 2]>, D: DimName, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: Copy, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<<N as SimdValue>::Element, D, D>,` [src]

`pub fn from(arr: [Rotation<<N as SimdValue>::Element, D>; 2]) -> Rotation<N, D>`[src]

`impl<N, D> From<[Rotation<<N as SimdValue>::Element, D>; 4]> for Rotation<N, D> where N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 4]>, D: DimName, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: Copy, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<<N as SimdValue>::Element, D, D>,` [src]

`pub fn from(arr: [Rotation<<N as SimdValue>::Element, D>; 4]) -> Rotation<N, D>`[src]

`impl<N, D> From<[Rotation<<N as SimdValue>::Element, D>; 8]> for Rotation<N, D> where N: Scalar + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 8]>, D: DimName, <N as SimdValue>::Element: Scalar, <N as SimdValue>::Element: Copy, DefaultAllocator: Allocator<N, D, D>, DefaultAllocator: Allocator<<N as SimdValue>::Element, D, D>,` [src]

`pub fn from(arr: [Rotation<<N as SimdValue>::Element, D>; 8]) -> Rotation<N, D>`[src]

`impl<N> From<Rotation<N, U2>> for Unit<Complex<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

`pub fn from(q: Rotation<N, U2>) -> Unit<Complex<N>>`[src]

`impl<N> From<Rotation<N, U2>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where N: RealField,` [src]

`pub fn from( q: Rotation<N, U2> ) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>`[src]

`impl<N> From<Rotation<N, U2>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where N: RealField,` [src]

`pub fn from( q: Rotation<N, U2> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

`impl<N> From<Rotation<N, U3>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where N: RealField,` [src]

`pub fn from( q: Rotation<N, U3> ) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>`[src]

`impl<N> From<Rotation<N, U3>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where N: RealField,` [src]

`pub fn from( q: Rotation<N, U3> ) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>`[src]

`impl<N> From<Rotation<N, U3>> for Unit<Quaternion<N>> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

`pub fn from(q: Rotation<N, U3>) -> Unit<Quaternion<N>>`[src]

`impl From<Rotation<f32, U3>> for Node`[src]

`pub fn from(r: Rotation<f32, U3>) -> Node`[src]

`impl<N> From<Unit<Complex<N>>> for Rotation<N, U2> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

`pub fn from(q: Unit<Complex<N>>) -> Rotation<N, U2>`[src]

`impl<N> From<Unit<Quaternion<N>>> for Rotation<N, U3> where N: SimdRealField, <N as SimdValue>::Element: SimdRealField,` [src]

`pub fn from(q: Unit<Quaternion<N>>) -> Rotation<N, U3>`[src]

`impl<N, D> Hash for Rotation<N, D> where N: Scalar + Hash, D: DimName + Hash, DefaultAllocator: Allocator<N, D, D>, <DefaultAllocator as Allocator<N, D, D>>::Buffer: Hash,` [src]

`pub fn hash<H>(&self, state: &mut H) where H: Hasher,` [src]

`pub fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0 [src]

`impl<N, D> Index<(usize, usize)> for Rotation<N, D> where N: Scalar, D: DimName, DefaultAllocator: Allocator<N, D, D>,` [src]

`type Output = N`

The returned type after indexing.