Struct Multivector 

pub struct Multivector<const P: usize, const Q: usize, const R: usize> { /* private fields */ }

A multivector in a Clifford algebra Cl(P,Q,R)

Type Parameters

• P: Number of basis vectors that square to +1
• Q: Number of basis vectors that square to -1
• R: Number of basis vectors that square to 0

Implementations

impl<const P: usize, const Q: usize, const R: usize> Multivector<P, Q, R>

pub const DIM: usize

Total dimension of the algebra’s vector space

pub const BASIS_COUNT: usize

Total number of basis blades (2^DIM)

pub fn zero() -> Self

Create a new zero multivector

pub fn scalar(value: f64) -> Self

Create a scalar multivector

pub fn from_vector(vector: &Vector<P, Q, R>) -> Self

Create multivector from vector

pub fn from_bivector(bivector: &Bivector<P, Q, R>) -> Self

Create multivector from bivector

pub fn basis_vector(i: usize) -> Self

Create a basis vector e_i (i starts from 0)

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

Create a multivector from coefficients

pub fn from_slice(coefficients: &[f64]) -> Self

Create a multivector from a slice (convenience for tests)

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

Get coefficient for a specific basis blade (by index)

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

Set coefficient for a specific basis blade

pub fn scalar_part(&self) -> f64

Get the scalar part (grade 0)

pub fn set_scalar(&mut self, value: f64)

Set the scalar part

pub fn vector_part(&self) -> Vector<P, Q, R>

Get vector part as a Vector type

pub fn bivector_part(&self) -> Self

Get bivector part as a Multivector (grade 2 projection)

pub fn bivector_type(&self) -> Bivector<P, Q, R>

Get bivector part as a Bivector type wrapper

pub fn trivector_part(&self) -> f64

Get trivector part (scalar for 3D)

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

Set vector component

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

Set bivector component

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

Get vector component

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

Get coefficients as slice for comparison

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

Add method for convenience

pub fn grade(&self) -> usize

Get the grade of a multivector (returns the highest non-zero grade)

pub fn outer_product_with_vector(&self, other: &Vector<P, Q, R>) -> Self

Outer product with a vector (convenience method)

pub fn geometric_product(&self, rhs: &Self) -> Self

Geometric product with another multivector

The geometric product is the fundamental operation in geometric algebra, combining both the inner and outer products.

pub fn geometric_product_scalar(&self, rhs: &Self) -> Self

Scalar implementation of geometric product (fallback)

pub fn inner_product(&self, rhs: &Self) -> Self

Inner product (grade-lowering, dot product for vectors)

pub fn outer_product(&self, rhs: &Self) -> Self

Outer product (wedge product, grade-raising)

pub fn scalar_product(&self, rhs: &Self) -> f64

Scalar product (grade-0 part of geometric product)

pub fn reverse(&self) -> Self

Reverse operation (reverses order of basis vectors in each blade)

pub fn grade_projection(&self, grade: usize) -> Self

Grade projection - extract components of a specific grade

pub fn is_zero(&self) -> bool

Check if this is (approximately) zero

pub fn norm_squared(&self) -> f64

Compute the norm squared (scalar product with reverse)

pub fn magnitude(&self) -> f64

Compute the magnitude (length) of this multivector

The magnitude is defined as |a| = √(a·ã) where ã is the reverse of a. This provides the natural norm inherited from the underlying vector space.

Mathematical Properties

• Always non-negative: |a| ≥ 0
• Zero iff a = 0: |a| = 0 ⟺ a = 0
• Sub-multiplicative: |ab| ≤ |a||b|

Examples

use amari_core::Multivector;
let v = Multivector::<3,0,0>::basis_vector(0);
assert_eq!(v.magnitude(), 1.0);

pub fn norm(&self) -> f64

Compute the norm (magnitude) of this multivector

Note: This method is maintained for backward compatibility. New code should prefer magnitude() for clarity.

pub fn abs(&self) -> f64

Absolute value (same as magnitude/norm for multivectors)

pub fn approx_eq(&self, other: &Self, epsilon: f64) -> bool

Approximate equality comparison

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

Normalize this multivector

pub fn inverse(&self) -> Option<Self>

Compute multiplicative inverse if it exists

pub fn exp(&self) -> Self

Exponential map for bivectors (creates rotors)

For a bivector B, exp(B) creates a rotor that performs rotation in the plane defined by B.

pub fn left_contraction(&self, other: &Self) -> Self

Left contraction: a ⌟ b

Generalized inner product where the grade of the result is |grade(b) - grade(a)|. The left operand’s grade is reduced.

pub fn right_contraction(&self, other: &Self) -> Self

Right contraction: a ⌞ b

Generalized inner product where the grade of the result is |grade(a) - grade(b)|. The right operand’s grade is reduced.

pub fn hodge_dual(&self) -> Self

Hodge dual: ⋆a

Maps k-vectors to (n-k)-vectors in n-dimensional space. Essential for electromagnetic field theory and differential forms. In 3D: scalar -> pseudoscalar, vector -> bivector, bivector -> vector, pseudoscalar -> scalar

Trait Implementations

impl<const P: usize, const Q: usize, const R: usize> Add for &Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Multivector<P, Q, R>

Performs the + operation.

impl<const P: usize, const Q: usize, const R: usize> Add for Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<const P: usize, const Q: usize, const R: usize> Clone for Multivector<P, Q, R>

fn clone(&self) -> Multivector<P, Q, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const P: usize, const Q: usize, const R: usize> Debug for Multivector<P, Q, R>

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

Formats the value using the given formatter.

impl<const P: usize, const Q: usize, const R: usize> Mul<f64> for &Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Multivector<P, Q, R>

Performs the * operation.

impl<const P: usize, const Q: usize, const R: usize> Mul<f64> for Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> Self

Performs the * operation.

impl<const P: usize, const Q: usize, const R: usize> Neg for Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<const P: usize, const Q: usize, const R: usize> PartialEq for Multivector<P, Q, R>

fn eq(&self, other: &Multivector<P, Q, R>) -> 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<const P: usize, const Q: usize, const R: usize> Sub for &Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Multivector<P, Q, R>

Performs the - operation.

impl<const P: usize, const Q: usize, const R: usize> Sub for Multivector<P, Q, R>

type Output = Multivector<P, Q, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<const P: usize, const Q: usize, const R: usize> Zero for Multivector<P, Q, R>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<const P: usize, const Q: usize, const R: usize> StructuralPartialEq for Multivector<P, Q, R>