Struct So3Algebra 

pub struct So3Algebra(/* private fields */);

Lie algebra so(3) ≅ ℝ³

Elements of so(3) are 3×3 real antisymmetric matrices, which we represent as 3-vectors via the natural isomorphism with ℝ³.

Isomorphism with ℝ³

An element v = (x, y, z) ∈ ℝ³ corresponds to the antisymmetric matrix:

[v]_× = [[0, -z, y], [z, 0, -x], [-y, x, 0]]

This satisfies: [v]_× · w = v × w (cross product)

Basis Elements

The standard basis corresponds to angular momentum operators:

L_x = (1, 0, 0) ↔ [[0, 0, 0], [0, 0, -1], [0, 1, 0]]
L_y = (0, 1, 0) ↔ [[0, 0, 1], [0, 0, 0], [-1, 0, 0]]
L_z = (0, 0, 1) ↔ [[0, -1, 0], [1, 0, 0], [0, 0, 0]]

Implementations

impl So3Algebra

pub fn new(components: [f64; 3]) -> Self

Create a new so(3) algebra element from components.

The components [x, y, z] correspond to the antisymmetric matrix [[0, -z, y], [z, 0, -x], [-y, x, 0]].

pub fn components(&self) -> &[f64; 3]

Returns the components as a fixed-size array reference.

Trait Implementations

impl AbsDiffEq for So3Algebra

type Epsilon = f64

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl Add<&So3Algebra> for &So3Algebra

type Output = So3Algebra

The resulting type after applying the + operator.

fn add(self, rhs: &So3Algebra) -> So3Algebra

Performs the + operation.

impl Add<&So3Algebra> for So3Algebra

type Output = So3Algebra

The resulting type after applying the + operator.

fn add(self, rhs: &So3Algebra) -> So3Algebra

Performs the + operation.

impl Add<So3Algebra> for &So3Algebra

type Output = So3Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for So3Algebra

type Output = So3Algebra

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for So3Algebra

fn clone(&self) -> So3Algebra

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for So3Algebra

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

Formats the value using the given formatter.

impl Display for So3Algebra

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

Formats the value using the given formatter.

impl LieAlgebra for So3Algebra

fn bracket(&self, other: &Self) -> Self

Lie bracket for so(3): [v, w] = v × w (cross product)

For so(3) ≅ ℝ³, the Lie bracket is exactly the vector cross product.

Properties

• Antisymmetric: [v, w] = -[w, v]
• Jacobi identity: [u, [v, w]] + [v, [w, u]] + [w, [u, v]] = 0

Examples

use lie_groups::so3::So3Algebra;
use lie_groups::traits::LieAlgebra;

let lx = So3Algebra::basis_element(0);  // (1, 0, 0)
let ly = So3Algebra::basis_element(1);  // (0, 1, 0)
let bracket = lx.bracket(&ly);           // (1,0,0) × (0,1,0) = (0,0,1)

// Should give L_z = (0, 0, 1)
assert!((bracket.components()[0]).abs() < 1e-10);
assert!((bracket.components()[1]).abs() < 1e-10);
assert!((bracket.components()[2] - 1.0).abs() < 1e-10);

const DIM: usize = 3

Dimension of the Lie algebra as a compile-time constant.

fn zero() -> Self

Zero element (additive identity) 0 ∈ 𝔤.

fn add(&self, other: &Self) -> Self

Add two algebra elements: v + w

fn scale(&self, scalar: f64) -> Self

Scalar multiplication: α · v

fn norm(&self) -> f64

Euclidean norm of the coefficient vector: ||v|| = √(Σᵢ vᵢ²)

fn basis_element(i: usize) -> Self

Get the i-th basis element of the Lie algebra.

fn from_components(components: &[f64]) -> Self

Construct algebra element from basis coordinates.

fn to_components(&self) -> Vec<f64>

Extract basis coordinates from algebra element.

fn inner(&self, other: &Self) -> f64

Inner product on coefficient space: ⟨v, w⟩ = Σᵢ vᵢ wᵢ

impl Mul<So3Algebra> for f64

type Output = So3Algebra

The resulting type after applying the * operator.

fn mul(self, rhs: So3Algebra) -> So3Algebra

Performs the * operation.

impl Mul<f64> for So3Algebra

type Output = So3Algebra

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for So3Algebra

type Output = So3Algebra

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for So3Algebra

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

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl Sub for So3Algebra

type Output = So3Algebra

The resulting type after applying the - operator.

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

Performs the - operation.

impl AntiHermitianByConstruction for So3Algebra

so(3) algebra elements are anti-Hermitian by construction.

Real antisymmetric matrices satisfy A^T = -A, which over ℝ is equivalent to A† = -A (anti-Hermitian).

impl Copy for So3Algebra

impl StructuralPartialEq for So3Algebra

impl TracelessByConstruction for So3Algebra

so(3) algebra elements are traceless by construction.

The representation So3Algebra::new([f64; 3]) stores coefficients for 3×3 antisymmetric matrices. All antisymmetric matrices are traceless.