Struct RPlus 

pub struct RPlus { /* private fields */ }

An element of ℝ⁺, the multiplicative group of positive reals

Represented as a positive real number x > 0.

Representation

We store the value directly (not logarithm) for intuitive interpretation. The logarithm is computed when needed for Lie algebra operations.

Examples

use lie_groups::{LieGroup, RPlus};

// Create elements
let g = RPlus::from_value(2.0);
let h = RPlus::from_value(3.0);

// Group multiplication
let product = g.compose(&h);
assert!((product.value() - 6.0).abs() < 1e-10);

// Inverse
let g_inv = g.inverse();
assert!((g_inv.value() - 0.5).abs() < 1e-10);

Implementations

impl RPlus

pub fn from_value(value: f64) -> Self

Create ℝ⁺ element from a positive real number

Panics

Panics if value <= 0.

Examples

use lie_groups::RPlus;

let g = RPlus::from_value(2.5);
assert!((g.value() - 2.5).abs() < 1e-10);

pub fn from_value_clamped(value: f64) -> Self

Create ℝ⁺ element, clamping to positive range

For robustness when value might be near zero or negative due to numerical errors. Clamps to a small positive value.

Examples

use lie_groups::RPlus;

let g = RPlus::from_value_clamped(-0.1);
assert!(g.value() > 0.0);

pub fn value(&self) -> f64

Get the positive real value

pub fn from_log(log_value: f64) -> Self

Create from logarithm (exponential map)

Given x ∈ ℝ (Lie algebra), returns eˣ ∈ ℝ⁺.

Examples

use lie_groups::RPlus;

let g = RPlus::from_log(0.0);  // e⁰ = 1
assert!((g.value() - 1.0).abs() < 1e-10);

let h = RPlus::from_log(1.0);  // e¹ ≈ 2.718
assert!((h.value() - std::f64::consts::E).abs() < 1e-10);

pub fn scaling(magnitude: f64) -> Self

Scaling perturbation for optimization

Returns a small scaling factor for gradient descent updates.

Arguments

• magnitude - Step size in log-space

pub fn random<R: Rng>(rng: &mut R, log_mean: f64, log_std: f64) -> Self

Random ℝ⁺ element (log-normal distribution)

Requires the rand feature (enabled by default). Samples from log-normal with given mean and std in log-space.

Panics

Panics if log_std is negative or NaN.

Trait Implementations

impl Clone for RPlus

fn clone(&self) -> RPlus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RPlus

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

Formats the value using the given formatter.

impl Display for RPlus

Display implementation

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

Formats the value using the given formatter.

impl LieGroup for RPlus

const MATRIX_DIM: usize = 1

Matrix dimension in the fundamental representation.

type Algebra = RPlusAlgebra

Associated Lie algebra type.

fn identity() -> Self

The identity element e ∈ G.

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

Group composition (multiplication): g₁ · g₂

fn inverse(&self) -> Self

Group inverse: g⁻¹

fn conjugate_transpose(&self) -> Self

Adjoint representation element (for matrix groups: conjugate transpose).

fn adjoint_action(&self, algebra_element: &RPlusAlgebra) -> RPlusAlgebra

Adjoint representation: Ad_g: 𝔤 → 𝔤

fn distance_to_identity(&self) -> f64

Geodesic distance from identity: d(g, e)

fn exp(tangent: &RPlusAlgebra) -> Self

Exponential map: 𝔤 → G

fn log(&self) -> LogResult<RPlusAlgebra>

Logarithm map: G → 𝔤 (inverse of exponential)

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

Distance between two group elements: d(g, h)

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

Check if this element is approximately the identity.

fn trace_identity() -> f64

Trace of the identity element

fn reorthogonalize(&self) -> Self

Project element back onto the group manifold using Gram-Schmidt orthogonalization.

fn geodesic(&self, other: &Self, t: f64) -> Option<Self>

Geodesic interpolation between two group elements.

impl Mul<&RPlus> for &RPlus

Group multiplication: g₁ · g₂ (real multiplication)

type Output = RPlus

The resulting type after applying the * operator.

fn mul(self, rhs: &RPlus) -> RPlus

Performs the * operation.

impl Mul<&RPlus> for RPlus

type Output = RPlus

The resulting type after applying the * operator.

fn mul(self, rhs: &RPlus) -> RPlus

Performs the * operation.

impl MulAssign<&RPlus> for RPlus

fn mul_assign(&mut self, rhs: &RPlus)

Performs the *= operation.

impl PartialEq for RPlus

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

ℝ⁺ is abelian: a · b = b · a for all positive reals.

impl Copy for RPlus

impl StructuralPartialEq for RPlus