Struct Biquaternion 

pub struct Biquaternion {
    pub components: [Complex<f64>; 4],
}

A quaternion with complex coefficients.

Biquaternions are the set of numbers $a + b\mathbf{i} + c\mathbf{j} + d\mathbf{k}$ where $a,b,c,d$ are complex numbers and $\{1,\mathbf{i},\mathbf{j},\mathbf{k}\}$ are the quaternion algebra. Biquaternions can be thought of as a generalization of quaternions which allow for complex coefficients. Analogous to quaternions and SO(3), biquaternions furnish a representation of SO(3,1)

Construction of Biquaternions

Create a biquaternion from an array of four complex numbers. Note that components are in the order $[\mathbf{i},\mathbf{j},\mathbf{k},1]$ (i.e., the scalar component is at the end)

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(1.0, 4.0),
    Complex::new(2.0, 3.0),
    Complex::new(3.0, 2.0),
    Complex::new(4.0, 1.0),
]);
assert_eq!(4.0, q.components[0].im);

Operations with Biquaternions.

Similar to Quaternion, biquaternions support vector operations (addition, multiplication by a scalar, etc.):

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let mut a = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(2.0, 0.0),
    Complex::new(3.0, 0.0),
    Complex::new(0.0, 1.0),
]);
let mut b = Biquaternion::from([
    Complex::new(0.0, 4.0),
    Complex::new(0.0, 3.0),
    Complex::new(0.0, 2.0),
    Complex::new(1.0, 0.0),
]);
b /= 2.0;
let mut c = a + b;
assert_eq!(Complex::new(1.0, 2.0), c.components[0]);

Biquaternions also support the following operations:

Hamiltonian conjugate/ biconjugate: Denoted by the method “bar”, the Hamiltonian conjugate multiplies the vector part of the biquaternion by -1.0.

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(-1.0, 0.0),
    Complex::new(-1.0, 2.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
let p = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(1.0, -2.0),
    Complex::new(-1.0, 0.0),
    Complex::new(1.0, 0.0),
]);

assert_eq!(p, q.bar());

Complex conjugation: Denoted by method “conj”, takes the complex conjugate of all components of the biquaternion

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(1.0, 8.0),
    Complex::new(2.0, 7.0),
    Complex::new(3.0, 6.0),
    Complex::new(4.0, 5.0),
]);
let p = Biquaternion::from([
    Complex::new(1.0, -8.0),
    Complex::new(2.0, -7.0),
    Complex::new(3.0, -6.0),
    Complex::new(4.0, -5.0),
]);

assert_eq!(p, q.conj());

Biquaternion Product: The biquaternion product takes two biquaternions and outputs another biquaternion.

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(2.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
let p = Biquaternion::from([
    Complex::new(3.0, 0.0),
    Complex::new(2.0, 0.0),
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 1.0),
]);
let c = Biquaternion::from([
    Complex::new(1.0, 3.0),
    Complex::new(2.0, 0.0),
    Complex::new(5.0, -2.0),
    Complex::new(-7.0, -1.0),
]);
assert_eq!(c, q.dot(&p));

Scalar Product: The scalar product takes two biquaternions and outputs a complex number according to

\frac{1}{2}(a\overline{b} + b\overline{a})

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(2.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
let p = Biquaternion::from([
    Complex::new(3.0, 0.0),
    Complex::new(2.0, 0.0),
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 1.0),
]);
assert_eq!(Complex::new(7.0, 3.0), q.scalar_product(&p));

Biquaternion Norm: The scalar product furnishes a “norm” for the biquaternion.

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(3.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(4.0, 0.0),
    Complex::new(0.0, 2.0),
]);
assert_eq!(Complex::new(20.0_f64, 0.0).sqrt(), q.norm());

Fields

components: [Complex<f64>; 4]

Components of the biquaternion, in the order [i,j,k,1].

Implementations

impl Biquaternion

pub fn bar(&self) -> Self

Compute the Hamiltonian conjugate or biconjugate of a biquaternion.

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(-1.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
let p = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(0.0, -1.0),
    Complex::new(-1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
assert_eq!(p, q.bar());

pub fn conj(&self) -> Self

Compute the complex conjugate of a biquaternion.

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 2.0),
]);
let p = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(0.0, -1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, -2.0),
]);
assert_eq!(p, q.conj());

pub fn norm_squared(&self) -> Complex<f64>

Compute the squared norm of a biquaternion.

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
assert_eq!(2.0, q.norm_squared().re);

pub fn norm(&self) -> Complex<f64>

the norm of a biquaternion

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(3.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(4.0, 0.0),
    Complex::new(1.0, 0.0),
]);
assert_eq!(Complex::new(5.0, 0.0), q.norm());

pub fn dot(&self, other: &Self) -> Self

Compute the quaternion product of two biquaternions.

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(2.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
let p = Biquaternion::from([
    Complex::new(3.0, 0.0),
    Complex::new(2.0, 0.0),
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 1.0),
]);
let c = Biquaternion::from([
    Complex::new(1.0, 3.0),
    Complex::new(2.0, 0.0),
    Complex::new(5.0, -2.0),
    Complex::new(-7.0, -1.0),
]);
assert_eq!(c, q.dot(&p));

pub fn scalar_product(&self, other: &Self) -> Complex<f64>

Compute the scalar product of two biquaternions.

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(2.0, 0.0),
    Complex::new(0.0, 1.0),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 0.0),
]);
let p = Biquaternion::from([
    Complex::new(3.0, 0.0),
    Complex::new(2.0, 0.0),
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 1.0),
]);
assert_eq!(Complex::new(7.0, 3.0), q.scalar_product(&p));

pub fn to_unit(self) -> Result<UnitBiquaternion, Error>

Create a UnitBiquaternion by normalizing the given biquaternion.

Errors

Error::InvalidBiquaternionMagnitude when self is the 0 quaternion.

pub fn to_unit_unchecked(self) -> UnitBiquaternion

Create a UnitBiquaternion by normalizing the given biquaternion.

Trait Implementations

impl Add for Biquaternion

type Output = Biquaternion

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl AddAssign for Biquaternion

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Biquaternion

fn clone(&self) -> Biquaternion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Biquaternion

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

Formats the value using the given formatter.

impl Default for Biquaternion

fn default() -> Self

Create a biquaternion with all zeros.

impl<'de> Deserialize<'de> for Biquaternion

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Biquaternion

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

Formats the value using the given formatter.

impl Div<Complex<f64>> for Biquaternion

type Output = Biquaternion

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f64>) -> Self

Performs the / operation.

impl Div<f64> for Biquaternion

type Output = Biquaternion

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self

Performs the / operation.

impl DivAssign<f64> for Biquaternion

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl From<[Complex<f64>; 4]> for Biquaternion

fn from(value: [Complex<f64>; 4]) -> Self

Construct a Biquaternion from 4 complex values.

Example

use hoomd_manifold::Biquaternion;
use num::complex::Complex;

let q = Biquaternion::from([
    Complex::new(1.0, 0.0),
    Complex::new(0.0, 0.1),
    Complex::new(1.0, 0.0),
    Complex::new(1.0, 1.0),
]);
assert_eq!(
    q.components,
    [
        Complex::new(1.0, 0.0),
        Complex::new(0.0, 0.1),
        Complex::new(1.0, 0.0),
        Complex::new(1.0, 1.0)
    ]
);

impl Mul<Complex<f64>> for Biquaternion

type Output = Biquaternion

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f64>) -> Self

Performs the * operation.

impl Mul<f64> for Biquaternion

type Output = Biquaternion

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self

Performs the * operation.

impl MulAssign<f64> for Biquaternion

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl PartialEq for Biquaternion

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Biquaternion

type Output = Biquaternion

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign for Biquaternion

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Biquaternion

impl StructuralPartialEq for Biquaternion