Struct Rn 

pub struct Rn { /* private fields */ }

Rⁿ group element representing n-dimensional Euclidean vectors.

Internally represented using nalgebra’s DVector for dynamic sizing.

Implementations

impl Rn

pub const DIM: usize = 0

Space dimension - dimension of the ambient space that the group acts on Note: For Rⁿ this is dynamic and determined at runtime

pub const DOF: usize = 0

Degrees of freedom - dimension of the tangent space Note: For Rⁿ this is dynamic and determined at runtime

pub const REP_SIZE: usize = 0

Representation size - size of the underlying data representation Note: For Rⁿ this is dynamic and determined at runtime

pub fn identity() -> Rn

Get the identity element of the group.

Returns the neutral element e such that e ∘ g = g ∘ e = g for any group element g. Note: Default to 3D identity for compatibility, but this should be created with specific dimension

pub fn jacobian_identity() -> Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>

Get the identity matrix for Jacobians.

Returns the identity matrix in the appropriate dimension for Jacobian computations. Note: Default to 3x3 identity, but this should be created with specific dimension

pub fn new( data: Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, ) -> Rn

Create a new Rⁿ element from a vector.

Arguments

• data - Vector data

pub fn from_slice(slice: &[f64]) -> Rn

Create Rⁿ from a slice.

Arguments

• slice - Data slice

pub fn from_vec(components: Vec<f64>) -> Rn

Create Rⁿ from individual components (up to 6D for convenience).

pub fn data( &self, ) -> &Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Get the underlying vector.

pub fn dim(&self) -> usize

Get the dimension of the space.

pub fn component(&self, index: usize) -> f64

Get a specific component.

pub fn set_component(&mut self, index: usize, value: f64)

Set a specific component.

pub fn norm(&self) -> f64

Get the norm (Euclidean length) of the vector.

pub fn norm_squared(&self) -> f64

Get the squared norm of the vector.

pub fn to_vector( &self, ) -> Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Convert Rn to a DVector

impl Rn

pub fn identity_with_dim(dim: usize) -> Rn

Create identity element with specific dimension.

For Euclidean space, the identity (additive neutral element) is the zero vector. The default identity() returns a 3D zero vector for compatibility. Use this method when you need a specific dimension.

pub fn zeros(dim: usize) -> Rn

Create Rn with specific dimension filled with zeros.

pub fn ones(dim: usize) -> Rn

Create Rn with specific dimension filled with ones.

pub fn random_with_dim(dim: usize) -> Rn

Create Rn with specific dimension and random values.

pub fn jacobian_identity_with_dim( dim: usize, ) -> Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>

Create identity matrix for Jacobians with specific dimension.

Trait Implementations

impl Clone for Rn

fn clone(&self) -> Rn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for Rn

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 Rn

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

Converts to this type from the input type.

impl Interpolatable for Rn

fn interp(&self, other: &Rn, t: f64) -> Rn

Linear interpolation in Euclidean space.

For parameter t ∈ [0,1]: interp(v₁, v₂, 0) = v₁, interp(v₁, v₂, 1) = v₂.

Arguments

• other - Target element for interpolation
• t - Interpolation parameter in [0,1]

fn slerp(&self, other: &Rn, t: f64) -> Rn

Spherical linear interpolation (same as linear for Euclidean space).

impl LieGroup for Rn

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

Rⁿ inverse (negation for additive group).

Arguments

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

Notes

For Euclidean space with addition: -v Jacobian of inverse: d(-v)/dv = -I

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

Rⁿ composition (vector addition).

Arguments

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

Notes

For Euclidean space: v₁ + v₂ Jacobians: d(v₁ + v₂)/dv₁ = I, d(v₁ + v₂)/dv₂ = I

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

Logarithmic map from manifold to tangent space.

Arguments

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

Notes

For Euclidean space, log is identity: log(v) = v Jacobian: dlog(v)/dv = I

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

Vee operator: log(g)^∨.

For Euclidean space, this is the same as log().

fn act( &self, vector: &Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, jacobian_self: Option<&mut <Rn 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>>

Action on a 3-vector (for compatibility with the trait).

Arguments

• vector - 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 transformed 3-vector.

Notes

For Euclidean space, the action is translation: v + x This only works if this Rⁿ element is 3-dimensional.

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

Get the adjoint matrix of Rⁿ.

Notes

For Euclidean space (abelian group), adjoint is identity.

fn random() -> Rn

Generate a random element.

fn is_approx(&self, other: &Rn, 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

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

Right plus operation: v ⊞ δ = v + δ.

For Euclidean space, this is simple vector addition.

Arguments

• tangent - Tangent vector perturbation
• jacobian_self - Optional Jacobian ∂(v ⊞ δ)/∂v = I
• jacobian_tangent - Optional Jacobian ∂(v ⊞ δ)/∂δ = I

Notes

For Euclidean space: v ⊞ δ = v + δ Jacobians: ∂(v + δ)/∂v = I, ∂(v + δ)/∂δ = I

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

Right minus operation: v₁ ⊟ v₂ = v₁ - v₂.

For Euclidean space, this is simple vector subtraction.

Arguments

• other - The reference element v₂
• jacobian_self - Optional Jacobian ∂(v₁ ⊟ v₂)/∂v₁ = I
• jacobian_other - Optional Jacobian ∂(v₁ ⊟ v₂)/∂v₂ = -I

Notes

For Euclidean space: v₁ ⊟ v₂ = v₁ - v₂ Jacobians: ∂(v₁ - v₂)/∂v₁ = I, ∂(v₁ - v₂)/∂v₂ = -I

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

Left plus operation: δ ⊞ v = δ + v.

For Euclidean space (abelian group), left plus is the same as right plus.

Arguments

• tangent - Tangent vector perturbation
• jacobian_tangent - Optional Jacobian ∂(δ ⊞ v)/∂δ = I
• jacobian_self - Optional Jacobian ∂(δ ⊞ v)/∂v = I

Notes

For abelian groups: δ ⊞ v = v ⊞ δ = δ + v

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

Left minus operation: v₁ ⊟ v₂ = v₁ - v₂.

For Euclidean space (abelian group), left minus is the same as right minus.

Arguments

• other - The reference element v₂
• jacobian_self - Optional Jacobian ∂(v₁ ⊟ v₂)/∂v₁ = I
• jacobian_other - Optional Jacobian ∂(v₁ ⊟ v₂)/∂v₂ = -I

Notes

For abelian groups: left minus = right minus

fn tangent_dim(&self) -> usize

Get the dimension of the tangent space for this Rⁿ element.

Returns

The actual runtime dimension of this Rⁿ element.

Notes

Overrides the default implementation to return the dynamic size based on the actual data vector length, since Rⁿ has variable dimension.

type TangentVector = RnTangent

The tangent space vector type

type JacobianMatrix = Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>

The Jacobian matrix type

type LieAlgebra = Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>

Associated Lie algebra type

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

Get the identity matrix for Jacobians.

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

Get a zero Jacobian matrix.

fn normalize(&mut self)

Normalize/project the element to the manifold.

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

Check if the element is approximately on the manifold.

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

impl PartialEq for Rn

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

const DIM: usize = 0

Dimension of the tangent space Note: For Rⁿ this is dynamic and determined at runtime

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

Exponential map for Euclidean space (identity).

Arguments

• jacobian - Optional Jacobian matrix of the Rn element wrt this.

Notes

For Euclidean space: exp(v) = v Jacobian: dexp(v)/dv = I

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

Hat operator: v^∧ (vector to matrix).

For Euclidean space, this could be interpreted as a diagonal matrix or simply return the vector as a column matrix.

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

Small adjoint (zero for abelian group).

fn lie_bracket(&self, _other: &RnTangent) -> <Rn as LieGroup>::TangentVector

Lie bracket for Euclidean space.

For abelian groups: [v, w] = 0

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

Check if the tangent vector is approximately equal to another tangent vector.

Arguments

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

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

Get the i-th generator of the Lie algebra.

For Euclidean space, generators are standard basis vectors.

fn zero() -> <Rn as LieGroup>::TangentVector

Zero tangent vector.

fn random() -> <Rn as LieGroup>::TangentVector

Random tangent vector.

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

Check if the tangent vector is approximately zero.

fn normalize(&mut self)

Normalize the tangent vector to unit norm.

fn normalized(&self) -> <Rn as LieGroup>::TangentVector

Return a unit tangent vector in the same direction.

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

Right Jacobian Jr.

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

Left Jacobian Jl.

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

Inverse of right Jacobian Jr⁻¹.

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

Inverse of left Jacobian Jl⁻¹.

fn is_dynamic() -> bool

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

impl StructuralPartialEq for Rn