Struct SO2 

pub struct SO2 { /* private fields */ }

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

Internally represented using nalgebra’s UnitComplex for efficient rotations.

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 = 2

Representation size - size of the underlying data representation

pub fn identity() -> SO2

Get the identity element of the group.

Returns the neutral element e such that e ∘ g = g ∘ e = g for any group element g.

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

Get the identity matrix for Jacobians.

Returns the identity matrix in the appropriate dimension for Jacobian computations.

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

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

Arguments

• complex - Unit complex number representing rotation

pub fn from_angle(angle: f64) -> SO2

Create SO(2) from an angle.

Arguments

• angle - Rotation angle in radians

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 From<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>> for SO2

fn from(data: Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>) -> SO2

Converts to this type from the input type.

impl LieGroup for SO2

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

SO2 inverse.

Arguments

• jacobian - Optional Jacobian matrix of the inverse wrt self.

Notes

Equation 118: SO(2) Inverse

R(θ)⁻¹ = R(-θ)

Equation 124: Jacobian of Inverse for SO(2)

J_R⁻¹_R = -I

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

SO2 composition.

Arguments

• other - Another SO2 element.
• jacobian_self - Optional Jacobian matrix of the composition wrt self.
• jacobian_other - Optional Jacobian matrix of the composition wrt other.

Notes

Equation 125: Jacobian of Composition for SO(2)

J_C_A = I J_C_B = I

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

Get the SO2 corresponding Lie algebra element in vector form.

Arguments

• jacobian - Optional Jacobian matrix of the tangent wrt to self.

Notes

Equation 115: Logarithmic map for SO(2)

θ = atan2(R(1,0), R(0,0))

Equation 126: Jacobian of Logarithmic map for SO(2)

J_log_R = I

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.

Arguments

• v - A 3-vector.
• jacobian_self - Optional Jacobian of the new object wrt this.
• jacobian_vector - Optional Jacobian of the new object wrt input object.

Returns

The rotated 3-vector.

Notes

This is a convenience function that treats the 3D vector as a 2D vector and ignores the z component.

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

Get the adjoint matrix of SO2 at this.

Notes

See Eq. (123).

fn random() -> SO2

Generate a random element.

fn normalize(&mut self)

Normalize the underlying complex number.

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

Check if the element is valid.

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

Vee operator: log(g)^∨.

Maps a group element g ∈ G to its tangent vector log(g)^∨ ∈ 𝔤. For SO(2), this is the same as log().

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

Check if the element is approximately equal to another element.

Arguments

• other - The other element to compare with
• tolerance - The tolerance for the comparison

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 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 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

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 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 is_dynamic() -> bool

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

impl StructuralPartialEq for SO2