Struct HyperbolicRotationMatrix 

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

Hyperbolic rotations in Minkowski Space

Construct a HyperbolicRotationMatrix to apply SO(N-1, 1) transformations to N-dimensional Minkowski vectors. For Minkowski 4-vectors, Biquaternion should be used instead for numerical stability. See documentation in HyperbolicAngle for details on SO(2,1) transformations (i.e., two-dimensional hyperbolic space), and in Biquaternion for details on SO(3,1) transformations (i.e., three-dimensional hyperbolic space).

In two dimensional hyperbolic space:

use hoomd_manifold::{
    HyperbolicAngle, HyperbolicRotate, HyperbolicRotationMatrix, Minkowski,
};
use std::f64::consts::PI;

fn rotate_about_z(minkowski_vector: &Minkowski<3>) -> Minkowski<3> {
    let generators = HyperbolicAngle::from((PI, 0.0_f64, 0.0_f64));
    let rotation_matrix = HyperbolicRotationMatrix::from(generators);
    rotation_matrix.hyperbolic_rotate(&minkowski_vector)
}

fn boost_in_x(minkowski_vector: &Minkowski<3>) -> Minkowski<3> {
    let generators = HyperbolicAngle::from((0.0_f64, 0.2_f64, 0.0_f64));
    let boost_matrix = HyperbolicRotationMatrix::from(generators);
    boost_matrix.hyperbolic_rotate(&minkowski_vector)
}

Trait Implementations

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

fn clone(&self) -> HyperbolicRotationMatrix<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 HyperbolicRotationMatrix<N>

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<HyperbolicAngle> for HyperbolicRotationMatrix<3>

fn from(angle_list: HyperbolicAngle) -> HyperbolicRotationMatrix<3>

Create a matrix belonging to SO(2,1) from the generators of the algebra so(2,1).

impl From<UnitBiquaternion> for HyperbolicRotationMatrix<4>

fn from(q: UnitBiquaternion) -> HyperbolicRotationMatrix<4>

Converts to this type from the input type.

impl<const N: usize> HyperbolicRotate<Minkowski<N>> for HyperbolicRotationMatrix<N>

fn hyperbolic_rotate(&self, vector: &Minkowski<N>) -> Minkowski<N>

Rotate a Minkowski<N> by a HyperbolicRotationMatrix

Examples

Rotate point in 2D hyperbolic space about z-axis:

use hoomd_manifold::{
    HyperbolicAngle, HyperbolicRotate, HyperbolicRotationMatrix, Minkowski,
};
use std::f64::consts::PI;

let v = Minkowski::from([1.0, 0.0, 1.0]);
let spatial_rotation = HyperbolicAngle::from((PI / 2.0, 0.0_f64, 0.0_f64));
let matrix = HyperbolicRotationMatrix::from(spatial_rotation);
let rotated = matrix.hyperbolic_rotate(&v);
let c = Minkowski::from([(PI / 2.0).cos(), (PI / 2.0).sin(), 1.0]);
assert_eq!(c, rotated);

Boost point in 2D hyperbolic space in x direction:

use hoomd_manifold::{
    HyperbolicAngle, HyperbolicRotate, HyperbolicRotationMatrix, Minkowski,
};
use num::complex::Complex;
use std::f64::consts::PI;

let v = Minkowski::from([1.0, 0.0, 1.0]);
let small_boost = HyperbolicAngle::from((0.0_f64, 0.1_f64, 0.0_f64));
let matrix = HyperbolicRotationMatrix::from(small_boost);
let rotated = matrix.hyperbolic_rotate(&v);
let c = Minkowski::from([
    (0.1_f64).sinh() + (0.1_f64).cosh(),
    0.0,
    (0.1_f64).sinh() + (0.1_f64).cosh(),
]);
assert_eq!(c, rotated);

Zero angles and rapidities does nothing:

use hoomd_manifold::{
    HyperbolicAngle, HyperbolicRotate, HyperbolicRotationMatrix, Minkowski,
};
use num::complex::Complex;
use std::f64::consts::PI;

let v = Minkowski::from([1.0, 2.0, 1.0]);
let identity = HyperbolicAngle::from((0.0_f64, 0.0_f64, 0.0_f64));
let matrix = HyperbolicRotationMatrix::from(identity);
let rotated = matrix.hyperbolic_rotate(&v);
let c = Minkowski::from([1.0, 2.0, 1.0]);
assert_eq!(c, rotated);

Rotate point in 3D hyperbolic space about y axis using matrix representation:

use approxim::assert_relative_eq;
use hoomd_manifold::{
    Biquaternion, HyperbolicRotate, HyperbolicRotationMatrix, Minkowski,
    UnitBiquaternion,
};
use num::complex::Complex;
use std::f64::consts::PI;

let q = Biquaternion::from([
    Complex::new(0.0, 0.0),
    Complex::new((PI / 4.0).sin(), 0.0),
    Complex::new(0.0, 0.0),
    Complex::new((PI / 4.0).cos(), 0.0),
]);
let v = q.to_unit()?;
let x = Minkowski::from([1.0, 0.0, 0.0, 1.0]);
let rotation = HyperbolicRotationMatrix::from(v);
let rotated = rotation.hyperbolic_rotate(&x);
assert_relative_eq!(rotated, [0.0, 0.0, -1.0, 1.0].into(), epsilon = 1e-12);

Boost point in 3D hyperbolic space in x direction using biquaternion algebra:

use approxim::assert_relative_eq;
use hoomd_manifold::{
    Biquaternion, HyperbolicRotate, Minkowski, UnitBiquaternion,
};
use num::complex::Complex;
use std::f64::consts::PI;

let x = Minkowski::from([0.0, 0.0, 0.0, 1.0]);
let q = Biquaternion::from([
    Complex::new(0.0, 0.25).sin(),
    Complex::new(0.0, 0.0),
    Complex::new(0.0, 0.0),
    Complex::new(0.0, 0.25).cos(),
]);
let v = q.to_unit()?;
let boosted = v.hyperbolic_rotate(&x);
assert_relative_eq!(
    boosted,
    [(0.5_f64).sinh(), 0.0, 0.0, (0.5_f64).cosh()].into(),
    epsilon = 1e-12
);

type Matrix = HyperbolicRotationMatrix<N>

Type of the related rotation matrix

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

fn eq(&self, other: &HyperbolicRotationMatrix<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> Serialize for HyperbolicRotationMatrix<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 HyperbolicRotationMatrix<N>

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