Struct SO2 

pub struct SO2 { /* private fields */ }

SO(2) group element representing rotations in 2D.

Stored as a single angle θ (radians). UnitComplex is derived on demand for math operations, keeping storage minimal and contiguous.

Implementations

impl SO2

pub const DIM: usize = 2

Space dimension - dimension of the ambient space that the group acts on

pub const DOF: usize = 1

Degrees of freedom - dimension of the tangent space

pub const REP_SIZE: usize = 1

Representation size - one angle θ

pub fn identity() -> SO2

Get the identity element of the group.

pub fn jacobian_identity() -> Matrix<f64, Const<1>, Const<1>, ArrayStorage<f64, 1, 1>>

Get the identity matrix for Jacobians.

pub fn new(complex: Unit<Complex<f64>>) -> SO2

Create a new SO(2) element from a unit complex number.

pub fn from_angle(angle: f64) -> SO2

Create SO(2) from an angle.

pub fn complex(&self) -> Unit<Complex<f64>>

Get the underlying unit complex number.

pub fn angle(&self) -> f64

Get the rotation angle in radians.

pub fn rotation_matrix( &self, ) -> Matrix<f64, Const<2>, Const<2>, ArrayStorage<f64, 2, 2>>

Get the rotation matrix (2x2).

Trait Implementations

impl Clone for SO2

fn clone(&self) -> SO2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for SO2

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

Formats the value using the given formatter.

impl LieGroup for SO2

fn inverse( &self, jacobian: Option<&mut <SO2 as LieGroup>::JacobianMatrix>, ) -> SO2

SO2 inverse: R(θ)⁻¹ = R(-θ).

fn compose( &self, other: &SO2, jacobian_self: Option<&mut <SO2 as LieGroup>::JacobianMatrix>, jacobian_other: Option<&mut <SO2 as LieGroup>::JacobianMatrix>, ) -> SO2

SO2 composition: angles add, wrapped via UnitComplex to stay in [-π, π].

fn log( &self, jacobian: Option<&mut <SO2 as LieGroup>::JacobianMatrix>, ) -> <SO2 as LieGroup>::TangentVector

Logarithmic map: returns the canonical angle in [-π, π].

fn act( &self, vector: &Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, _jacobian_self: Option<&mut <SO2 as LieGroup>::JacobianMatrix>, _jacobian_vector: Option<&mut Matrix<f64, Const<3>, Const<3>, ArrayStorage<f64, 3, 3>>>, ) -> Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>

Rotation action on a 3-vector (operates on the xy-plane).

fn adjoint(&self) -> <SO2 as LieGroup>::JacobianMatrix

Adjoint for SO(2) is identity (abelian group).

fn normalize(&mut self)

Normalize: wrap angle to [-π, π] using UnitComplex.

fn is_valid(&self, _tolerance: f64) -> bool

Any finite angle is valid.

const NAME: &'static str = "SO2"

Human-readable name for serialization and logging.

type TangentVector = SO2Tangent

The tangent space vector type

type JacobianMatrix = Matrix<f64, Const<1>, Const<1>, ArrayStorage<f64, 1, 1>>

The Jacobian matrix type

type LieAlgebra = Matrix<f64, Const<2>, Const<2>, ArrayStorage<f64, 2, 2>>

Associated Lie algebra type

fn random() -> SO2

Generate a random element (useful for testing and initialization).

fn jacobian_identity() -> <SO2 as LieGroup>::JacobianMatrix

Get the identity matrix for Jacobians.

fn zero_jacobian() -> <SO2 as LieGroup>::JacobianMatrix

Get a zero Jacobian matrix.

fn vee(&self) -> <SO2 as LieGroup>::TangentVector

Vee operator: log(g)^∨.

fn is_approx(&self, other: &SO2, tolerance: f64) -> bool

Check if the element is approximately equal to another element.

fn as_param_slice(&self) -> &[f64]

Returns the manifold parameters as a contiguous flat slice.

fn as_param_slice_mut(&mut self) -> &mut [f64]

Mutably borrows the raw parameter storage for in-place retraction updates.

fn from_param_slice(s: &[f64]) -> SO2

Constructs from a raw parameter slice (same layout as as_param_slice).

fn right_plus( &self, tangent: &Self::TangentVector, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_tangent: Option<&mut Self::JacobianMatrix>, ) -> Self

Right plus operation: g ⊞ φ = g ∘ exp(φ^∧).

fn right_minus( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self::TangentVector

Right minus operation: g₁ ⊟ g₂ = log(g₂⁻¹ ∘ g₁)^∨.

fn left_plus( &self, tangent: &Self::TangentVector, jacobian_tangent: Option<&mut Self::JacobianMatrix>, jacobian_self: Option<&mut Self::JacobianMatrix>, ) -> Self

Left plus operation: φ ⊞ g = exp(φ^∧) ∘ g.

fn left_minus( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self::TangentVector

Left minus operation: g₁ ⊟ g₂ = log(g₁ ∘ g₂⁻¹)^∨.

fn plus( &self, tangent: &Self::TangentVector, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_tangent: Option<&mut Self::JacobianMatrix>, ) -> Self

Convenience method for right_plus. Equivalent to g ⊞ φ.

fn minus( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self::TangentVector

Convenience method for right_minus. Equivalent to g₁ ⊟ g₂.

fn between( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self

Compute g₁⁻¹ ∘ g₂ (relative transformation).

fn tangent_dim(&self) -> usize

Get the dimension of the tangent space for this manifold element.

impl PartialEq for SO2

fn eq(&self, other: &SO2) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SO2

impl Tangent<SO2> for SO2Tangent

const DIM: usize = 1

Dimension of the tangent space

fn exp(&self, jacobian: Option<&mut <SO2 as LieGroup>::JacobianMatrix>) -> SO2

SO2 exponential map.

Arguments

• tangent - Tangent vector (angle)
• jacobian - Optional Jacobian matrix of the SE(3) element wrt this.

fn right_jacobian(&self) -> <SO2 as LieGroup>::JacobianMatrix

Right Jacobian for SO(2) is identity.

fn left_jacobian(&self) -> <SO2 as LieGroup>::JacobianMatrix

Left Jacobian for SO(2) is identity.

fn right_jacobian_inv(&self) -> <SO2 as LieGroup>::JacobianMatrix

Inverse of right Jacobian for SO(2) is identity.

fn left_jacobian_inv(&self) -> <SO2 as LieGroup>::JacobianMatrix

Inverse of left Jacobian for SO(2) is identity.

fn hat(&self) -> <SO2 as LieGroup>::LieAlgebra

Hat operator: θ^∧ (scalar to skew-symmetric matrix).

fn zero() -> SO2Tangent

Zero tangent vector for SO2

fn random() -> SO2Tangent

Random tangent vector for SO2

fn is_zero(&self, tolerance: f64) -> bool

Check if tangent vector is zero

fn normalize(&mut self)

Normalize tangent vector

fn normalized(&self) -> SO2Tangent

Return a unit tangent vector in the same direction.

fn small_adj(&self) -> <SO2 as LieGroup>::JacobianMatrix

Small adjoint matrix for SO(2).

For SO(2), the small adjoint is zero (since it’s commutative).

fn lie_bracket(&self, _other: &SO2Tangent) -> <SO2 as LieGroup>::TangentVector

Lie bracket for SO(2).

For SO(2), the Lie bracket is always zero since it’s commutative.

fn is_approx(&self, other: &SO2Tangent, tolerance: f64) -> bool

Check if this tangent vector is approximately equal to another.

Arguments

• other - The other tangent vector to compare with
• tolerance - The tolerance for the comparison

fn generator(&self, i: usize) -> <SO2 as LieGroup>::LieAlgebra

Get the ith generator of the SO(2) Lie algebra.

Arguments

• i - Index of the generator (must be 0 for SO(2))

Returns

The generator matrix

fn as_slice(&self) -> &[f64]

Borrows the raw tangent data as a flat slice. Zero allocation.

fn from_slice(s: &[f64]) -> SO2Tangent

Constructs from a raw slice (same layout as as_slice).

fn is_dynamic() -> bool

Whether this tangent type has dynamic (runtime-determined) dimension.