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() -> Multivector<P, Q, R>

Create a new zero multivector

pub fn scalar(value: f64) -> Multivector<P, Q, R>

Create a scalar multivector

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

Create multivector from vector

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

Create multivector from bivector

pub fn basis_vector(i: usize) -> Multivector<P, Q, R>

Create a basis vector e_i (i starts from 0)

pub fn from_coefficients(coefficients: Vec<f64>) -> Multivector<P, Q, R>

Create a multivector from coefficients

pub fn from_slice(coefficients: &[f64]) -> Multivector<P, Q, R>

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) -> Multivector<P, Q, R>

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 to_vec(&self) -> Vec<f64>

Convert coefficients to owned vector

Useful for interoperability with other libraries and serialization.

pub fn grade_project(&self, grade: usize) -> Multivector<P, Q, R>

Grade projection with alternative name for clarity

Alias for grade_projection that emphasizes the projection operation.

pub fn wedge(&self, other: &Multivector<P, Q, R>) -> Multivector<P, Q, R>

Wedge product (alias for outer product)

The wedge product ∧ is the antisymmetric outer product, fundamental to exterior algebra and differential forms.

pub fn dot(&self, other: &Multivector<P, Q, R>) -> Multivector<P, Q, R>

Dot product (alias for inner product)

The dot product · is the grade-lowering inner product, generalizing the vector dot product to all grades.

pub fn add(&self, other: &Multivector<P, Q, R>) -> Multivector<P, Q, R>

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>, ) -> Multivector<P, Q, R>

Outer product with a vector (convenience method)

pub fn geometric_product( &self, rhs: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

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: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

Scalar implementation of geometric product (fallback)

pub fn inner_product(&self, rhs: &Multivector<P, Q, R>) -> Multivector<P, Q, R>

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

pub fn outer_product(&self, rhs: &Multivector<P, Q, R>) -> Multivector<P, Q, R>

Outer product (wedge product, grade-raising)

pub fn scalar_product(&self, rhs: &Multivector<P, Q, R>) -> f64

Scalar product (grade-0 part of geometric product)

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

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

pub fn grade_projection(&self, grade: usize) -> Multivector<P, Q, R>

Grade projection - extract components of a specific grade

pub fn grade_magnitude(&self, grade: usize) -> f64

Compute the magnitude of a specific grade component.

This extracts the k-vector part and computes its magnitude. Useful for determining grade dominance in holographic representations.

Arguments

• grade - The grade to compute magnitude for (0=scalar, 1=vector, 2=bivector, etc.)

Returns

The magnitude of the grade-k component, or 0.0 if no such component exists.

Example

use amari_core::Multivector;
let mv = Multivector::<3,0,0>::basis_vector(0) + Multivector::<3,0,0>::scalar(2.0);
assert!((mv.grade_magnitude(0) - 2.0).abs() < 1e-10);  // scalar part
assert!((mv.grade_magnitude(1) - 1.0).abs() < 1e-10);  // vector part

pub fn grade_spectrum(&self) -> Vec<f64>

Get all grade magnitudes as a vector.

Returns the magnitude of each grade component from 0 to DIM. This provides a “grade spectrum” view of the multivector.

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: &Multivector<P, Q, R>, epsilon: f64) -> bool

Approximate equality comparison

pub fn normalize(&self) -> Option<Multivector<P, Q, R>>

Normalize this multivector

pub fn inverse(&self) -> Option<Multivector<P, Q, R>>

Compute multiplicative inverse if it exists

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

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: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

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: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

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) -> Multivector<P, Q, R>

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: &Multivector<P, Q, R>) -> 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: Multivector<P, Q, R>) -> Multivector<P, Q, R>

Performs the + operation.

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

type Adjoint = MatrixOperator<P, Q, R>

The type of the adjoint operator.

fn adjoint(&self) -> Self::Adjoint

Compute the adjoint operator.

fn is_self_adjoint(&self) -> bool

Check if this operator is self-adjoint (T = T*).

fn is_normal(&self) -> bool

Check if this operator is normal (TT* = T*T).

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

fn is_cauchy_sequence( &self, sequence: &[Multivector<P, Q, R>], tolerance: f64, ) -> bool

Check if a sequence appears to be Cauchy.

fn sequence_limit( &self, sequence: &[Multivector<P, Q, R>], tolerance: f64, ) -> Result<Multivector<P, Q, R>>

Compute the limit of a Cauchy sequence if it exists.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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

fn operator_norm(&self) -> f64

Compute or estimate the operator norm ||T||.

fn is_bounded_by(&self, bound: f64) -> bool

Check if the operator is bounded by a given constant.

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> CompactOperator<Multivector<P, Q, R>> for CompactMatrixOperator<P, Q, R>

fn is_finite_rank(&self) -> bool

Check if the operator has finite rank.

fn rank(&self) -> Option<usize>

Get the rank (dimension of range) if finite.

fn singular_values(&self) -> Result<Vec<f64>>

Get the singular values (if computable).

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

fn is_finite_rank(&self) -> bool

Check if the operator has finite rank.

fn rank(&self) -> Option<usize>

Get the rank (dimension of range) if finite.

fn singular_values(&self) -> Result<Vec<f64>>

Get the singular values (if computable).

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

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

Formats the value using the given formatter.

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

fn kernel_dimension(&self) -> usize

Compute the dimension of the kernel.

fn cokernel_dimension(&self) -> usize

Compute the dimension of the cokernel.

fn index(&self) -> i64

Compute the Fredholm index: dim(ker T) - dim(coker T).

fn is_isomorphism(&self) -> bool

Check if the operator is an isomorphism (index 0, trivial kernel).

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

fn kernel_dimension(&self) -> usize

Compute the dimension of the kernel.

fn cokernel_dimension(&self) -> usize

Compute the dimension of the cokernel.

fn index(&self) -> i64

Compute the Fredholm index: dim(ker T) - dim(coker T).

fn is_isomorphism(&self) -> bool

Check if the operator is an isomorphism (index 0, trivial kernel).

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

fn riesz_representative<F>(&self, functional: F) -> Result<Multivector<P, Q, R>>

where F: Fn(&Multivector<P, Q, R>) -> f64,

Apply the Riesz representation theorem.

fn orthogonal_complement_projection(&self, x: &V, subspace_basis: &[V]) -> V

where S: Into<f64> + From<f64>, V: Clone,

Compute the orthogonal complement projection.

fn best_approximation(&self, x: &V, subspace_basis: &[V]) -> V

where S: Into<f64> + From<f64>, V: Clone,

Compute the best approximation to x from a subspace.

fn is_orthonormal(&self, vectors: &[V], tolerance: f64) -> bool

where S: Into<f64>,

Check if a set of vectors forms an orthonormal system.

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

fn inner_product( &self, x: &Multivector<P, Q, R>, y: &Multivector<P, Q, R>, ) -> f64

Compute the inner product of two vectors.

fn project( &self, x: &Multivector<P, Q, R>, y: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

Project x onto y.

fn gram_schmidt( &self, vectors: &[Multivector<P, Q, R>], ) -> Vec<Multivector<P, Q, R>>

Gram-Schmidt orthogonalization of a set of vectors.

fn are_orthogonal(&self, x: &V, y: &V, tolerance: f64) -> bool

where S: Into<f64>,

Check if two vectors are orthogonal.

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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

fn apply(&self, _x: &Multivector<P, Q, R>) -> Result<Multivector<P, Q, R>>

Apply the operator to an element.

fn domain_dimension(&self) -> Option<usize>

Get the domain dimension (None if infinite).

fn codomain_dimension(&self) -> Option<usize>

Get the codomain dimension (None if infinite).

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) -> Multivector<P, Q, R>

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) -> Multivector<P, Q, R>

Performs the unary - operation.

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

fn norm(&self, x: &Multivector<P, Q, R>) -> f64

Compute the norm of a vector.

fn normalize(&self, x: &Multivector<P, Q, R>) -> Option<Multivector<P, Q, R>>

Normalize a vector to unit length.

fn distance(&self, x: &V, y: &V) -> f64

Compute the distance between two vectors.

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: &Multivector<P, Q, R>) -> 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: Multivector<P, Q, R>) -> Multivector<P, Q, R>

Performs the - operation.

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

fn add( &self, x: &Multivector<P, Q, R>, y: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

Add two vectors.

fn sub( &self, x: &Multivector<P, Q, R>, y: &Multivector<P, Q, R>, ) -> Multivector<P, Q, R>

Subtract two vectors.

fn scale(&self, scalar: f64, x: &Multivector<P, Q, R>) -> Multivector<P, Q, R>

Multiply a vector by a scalar.

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

Return the zero vector.

fn dimension(&self) -> Option<usize>

Return the dimension of the space (may be infinite).

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

fn zero() -> Multivector<P, Q, R>

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>