Struct RotationMatrix 

pub struct RotationMatrix<const N: usize> { /* private fields */ }

Rotate vectors efficiently.

Construct a RotationMatrix to efficiently rotate many vectors by the same rotation.

See:

• RotationMatrix::from<Angle>
• RotationMatrix::from<Versor>

RotationMatrix intentionally does not implement Rotation. Angle and Versor are representations of rotations that are often the most effective and numerically stable to manipulate.

Implementations

impl<const N: usize> RotationMatrix<N>

pub fn rows(&self) -> [Cartesian<N>; N]

Get the rows of the rotation matrix.

Example

use hoomd_vector::{Angle, InnerProduct, RotationMatrix, Vector};
use std::f64::consts::PI;

let a = Angle::from(PI / 2.0);

let matrix = RotationMatrix::from(a);
assert!(matrix.rows()[0].dot(&[0.0, -1.0].into()) > 0.99);
assert!(matrix.rows()[1].dot(&[1.0, 0.0].into()) > 0.99);

pub fn inverted(self) -> Self

Create a matrix that performs the inverse rotation.

Matrix inversion is cheaper than Angle -> RotationMatrix and Versor -> RotationMatrix conversions. When you need both rotations, convert once and then invert.

Example

use hoomd_vector::{Angle, InnerProduct, RotationMatrix, Vector};
use std::f64::consts::PI;

let a = Angle::from(PI / 2.0);

let matrix = RotationMatrix::from(a);
let inverted_matrix = matrix.inverted();
assert!(inverted_matrix.rows()[0].dot(&[0.0, 1.0].into()) > 0.99);
assert!(inverted_matrix.rows()[1].dot(&[-1.0, 0.0].into()) > 0.99);

Trait Implementations

impl<const N: usize> Clone for RotationMatrix<N>

fn clone(&self) -> RotationMatrix<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for RotationMatrix<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for RotationMatrix<N>

fn default() -> RotationMatrix<N>

Create an identity matrix.

\begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}

,

\begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix}

, and so on.

Example

use hoomd_vector::RotationMatrix;

let identity = RotationMatrix::<3>::default();

impl<'de, const N: usize> Deserialize<'de> for RotationMatrix<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> Display for RotationMatrix<N>

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

Formats the value using the given formatter.

impl From<Angle> for RotationMatrix<2>

fn from(angle: Angle) -> RotationMatrix<2>

Construct a rotation matrix equivalent to this angle’s rotation.

When rotating many vectors by the same Angle, improve performance by converting to a matrix first and applying that matrix to the vectors.

Example

use approxim::assert_relative_eq;
use hoomd_vector::{Angle, Cartesian, Rotate, RotationMatrix};
use std::f64::consts::PI;

let v = Cartesian::from([-1.0, 0.0]);
let a = Angle::from(PI / 2.0);

let matrix = RotationMatrix::from(a);
let rotated = matrix.rotate(&v);
assert_relative_eq!(rotated, [0.0, -1.0].into());

impl<const N: usize> From<RotationMatrix<N>> for Matrix<N, N>

fn from(value: RotationMatrix<N>) -> Self

Converts to this type from the input type.

impl From<Versor> for RotationMatrix<3>

fn from(versor: Versor) -> RotationMatrix<3>

Construct a rotation matrix equivalent to this versor’s rotation.

When rotating many vectors by the same Versor, improve performance by converting to a matrix first and applying that matrix to the vectors.

Example

use approxim::assert_relative_eq;
use hoomd_vector::{Cartesian, Rotate, RotationMatrix, Versor};
use std::f64::consts::PI;

let a = Cartesian::from([-1.0, 0.0, 0.0]);
let v = Versor::from_axis_angle([0.0, 0.0, 1.0].try_into()?, PI / 2.0);

let matrix = RotationMatrix::from(v);
let b = matrix.rotate(&a);
assert_relative_eq!(b, [0.0, -1.0, 0.0].into());

impl<const N: usize, const K: usize> MatMul<Matrix<N, K>> for RotationMatrix<N>

type Output = Matrix<N, K>

The type of the output matrix.

fn matmul(&self, rhs: &Matrix<N, K>) -> Self::Output

Multiply two matrices.

impl<const N: usize> PartialEq for RotationMatrix<N>

fn eq(&self, other: &RotationMatrix<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Rotate<Cartesian<N>> for RotationMatrix<N>

fn rotate(&self, vector: &Cartesian<N>) -> Cartesian<N>

Rotate a Cartesian<N> by a RotationMatrix

Examples

use approxim::assert_relative_eq;
use hoomd_vector::{Angle, Cartesian, Rotate, RotationMatrix};
use std::f64::consts::PI;

let v = Cartesian::from([-1.0, 0.0]);
let a = Angle::from(PI / 2.0);

let matrix = RotationMatrix::from(a);
let rotated = matrix.rotate(&v);
assert_relative_eq!(rotated, [0.0, -1.0].into());

use approxim::assert_relative_eq;
use hoomd_vector::{Cartesian, Rotate, RotationMatrix, Versor};
use std::f64::consts::PI;

let a = Cartesian::from([-1.0, 0.0, 0.0]);
let v = Versor::from_axis_angle([0.0, 0.0, 1.0].try_into()?, PI / 2.0);

let matrix = RotationMatrix::from(v);
let b = matrix.rotate(&a);
assert_relative_eq!(b, [0.0, -1.0, 0.0].into());

type Matrix = RotationMatrix<N>

Type of the related rotation matrix

impl<const N: usize> Serialize for RotationMatrix<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> Copy for RotationMatrix<N>

impl<const N: usize> StructuralPartialEq for RotationMatrix<N>