Struct GeometricState 

pub struct GeometricState { /* private fields */ }

State that lives in geometric space with explicit transformation support.

Unlike Behavior<T>, which hides the geometric representation, GeometricState exposes it directly. This is useful for:

• Animation with geometric interpolation (SLERP)
• Physics simulations
• Explicit rotation/translation control
• Advanced users who understand geometric algebra

Implementations

impl GeometricState

pub fn new(mv: GA3) -> Self

Create a new geometric state from a multivector

pub fn from_scalar(value: f64) -> Self

Create state representing a scalar value

pub fn from_vector(x: f64, y: f64, z: f64) -> Self

Create state representing a 3D vector/position

pub fn from_bivector(xy: f64, xz: f64, yz: f64) -> Self

Create state representing a bivector (rotation plane)

pub fn from_coefficients(coeffs: Vec<f64>) -> Self

Create state from raw coefficients

pub fn zero() -> Self

Create the zero state

pub fn identity() -> Self

Create the identity state (scalar 1)

pub fn multivector(&self) -> GA3

Get the underlying multivector (cloned)

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

Get the raw coefficient at a given index

pub fn scalar(&self) -> f64

Get the scalar component

pub fn as_vector(&self) -> (f64, f64, f64)

Get the vector components (e1, e2, e3) as a tuple

pub fn as_typed_vector(&self) -> Vector<3, 0, 0>

Get the vector components as a typed Vector<3,0,0>

pub fn as_bivector(&self) -> (f64, f64, f64)

Get the bivector components (e12, e13, e23) as a tuple

pub fn as_typed_bivector(&self) -> Bivector<3, 0, 0>

Get the bivector components as a typed Bivector<3,0,0>

pub fn magnitude(&self) -> f64

Get the magnitude (norm) of the state

pub fn project<P: Projection>(&self, projection: &P) -> P::Output

Project using a projection type

pub fn set(&self, mv: GA3)

Set the state to a new multivector

pub fn set_scalar(&self, value: f64)

Set the scalar value

pub fn set_vector(&self, x: f64, y: f64, z: f64)

Set the vector value from components

pub fn set_typed_vector(&self, v: &Vector<3, 0, 0>)

Set the vector value from a typed Vector<3,0,0>

pub fn set_typed_bivector(&self, b: &Bivector<3, 0, 0>)

Set the bivector value from a typed Bivector<3,0,0>

pub fn update<F>(&self, f: F)

where F: FnOnce(&GA3) -> GA3,

Update the state by applying a function

pub fn apply_rotor(&self, rotor: &Rotor) -> GeometricState

Apply a rotor transformation (rotation)

This creates a new state; the original is unchanged.

pub fn apply_rotor_mut(&self, rotor: &Rotor)

Apply a rotor transformation in-place

pub fn apply_translation(&self, translation: &Translation) -> GeometricState

Apply a translation

This creates a new state; the original is unchanged.

pub fn apply_translation_mut(&self, translation: &Translation)

Apply a translation in-place

pub fn apply_versor(&self, versor: &Versor) -> GeometricState

Apply a versor transformation

This creates a new state; the original is unchanged.

pub fn apply_versor_mut(&self, versor: &Versor)

Apply a versor transformation in-place

pub fn apply_transform(&self, transform: &Transform) -> GeometricState

Apply a general transform (rotation + translation)

This creates a new state; the original is unchanged.

pub fn apply_transform_mut(&self, transform: &Transform)

Apply a general transform in-place

pub fn add(&self, other: &GeometricState) -> GeometricState

Add another state (geometric addition)

pub fn sub(&self, other: &GeometricState) -> GeometricState

Subtract another state

pub fn scale(&self, factor: f64) -> GeometricState

Scale by a scalar value

pub fn geometric_product(&self, other: &GeometricState) -> GeometricState

Geometric product with another state

pub fn normalize(&self) -> Option<GeometricState>

Normalize the state to unit magnitude

pub fn normalize_mut(&self) -> bool

Normalize in-place

pub fn reverse(&self) -> GeometricState

Get the reverse (reversion) of this state

pub fn lerp(&self, other: &GeometricState, t: f64) -> GeometricState

Linear interpolation to another state

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

Spherical linear interpolation (for rotor-like states)

This assumes both states are unit rotors.

pub fn subscribe<F>(&self, callback: F) -> GeometricSubscription

where F: Fn(&GA3) + Send + Sync + 'static,

Subscribe to state changes

Trait Implementations

impl Clone for GeometricState

fn clone(&self) -> GeometricState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GeometricState

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

Formats the value using the given formatter.