Struct DualMultivector 

pub struct DualMultivector<T, const P: usize, const Q: usize, const R: usize>
where
    T: Float,
{ /* private fields */ }

Multivector with dual number coefficients for automatic differentiation

Implementations

impl<T, const P: usize, const Q: usize, const R: usize> DualMultivector<T, P, Q, R>

where T: Float,

pub fn zero() -> DualMultivector<T, P, Q, R>

Create zero dual multivector

pub fn from_dual_coefficients( coeffs: Vec<DualNumber<T>>, ) -> DualMultivector<T, P, Q, R>

Create from dual number coefficients

pub fn new_variables(values: &[T]) -> DualMultivector<T, P, Q, R>

Create dual multivector where each coefficient is a variable

pub fn new_variable(values: &[T]) -> DualMultivector<T, P, Q, R>

Create dual multivector where each coefficient is a variable - alias

pub fn constant_mv(mv: &Multivector<P, Q, R>) -> DualMultivector<T, P, Q, R>

Create constant dual multivector from Multivector

pub fn constant(values: &[T]) -> DualMultivector<T, P, Q, R>

Create constant dual multivector from slice

pub fn get(&self, index: usize) -> DualNumber<T>

Get coefficient at index

pub fn set(&mut self, index: usize, value: DualNumber<T>)

Set coefficient at index

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

Get the value part (without derivatives)

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

Get the derivative part

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

Get the real part (value) as a Multivector

pub fn magnitude(&self) -> T

Compute magnitude of the real part

pub fn from_real_multivector( mv: Multivector<P, Q, R>, ) -> DualMultivector<T, P, Q, R>

Create from real multivector (alias for constant_mv)

pub fn scalar(value: DualNumber<T>) -> DualMultivector<T, P, Q, R>

Create scalar dual multivector from DualNumber

pub fn basis_vector( index: usize, ) -> Result<DualMultivector<T, P, Q, R>, &'static str>

Create a basis vector (unit vector in given direction)

pub fn grade(&self) -> usize

Get the grade of the multivector (highest grade component with non-zero coefficient)

pub fn geometric_product( &self, other: &DualMultivector<T, P, Q, R>, ) -> DualMultivector<T, P, Q, R>

Geometric product with automatic differentiation

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

Reverse with automatic differentiation

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

Grade projection with automatic differentiation

pub fn norm_squared(&self) -> DualNumber<T>

Dual number norm (with automatic differentiation)

pub fn norm(&self) -> DualNumber<T>

Dual number norm

pub fn normalize(&self) -> DualMultivector<T, P, Q, R>

Normalize with automatic differentiation

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

Exponential map with automatic differentiation

pub fn map<F, G>(&self, f: F, df: G) -> DualMultivector<T, P, Q, R>

where F: Fn(T) -> T, G: Fn(T) -> T,

Apply a function element-wise with automatic differentiation

pub fn forward_mode_ad<F>(&self, f: F) -> (T, DualMultivector<T, P, Q, R>)

where F: Fn(DualMultivector<T, P, Q, R>) -> DualMultivector<T, P, Q, R>,

Forward-mode automatic differentiation

Computes both the value and gradient of a function using dual numbers. Forward-mode AD propagates derivatives alongside function evaluation, allowing exact derivative computation without finite differences.

Parameters

• f: A function that takes a DualMultivector and returns a DualMultivector

Returns

A tuple containing:

• The scalar value of the function at the input point
• The full DualMultivector result containing all partial derivatives

Example

use amari_dual::{DualMultivector, DualNumber};
let input = DualMultivector::<f64, 3, 0, 0>::scalar(DualNumber::constant(2.0));
let (value, gradient) = input.forward_mode_ad(|x| {
    x.geometric_product(&x)  // x^2 in geometric algebra
});
// Computes geometric square and its derivative

How it works

The dual number coefficients automatically track derivatives through all arithmetic operations via operator overloading. The ‘dual’ part of each number carries the derivative information, which is propagated according to the chain rule during computation.

Trait Implementations

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

where T: Float,

type Output = DualMultivector<T, P, Q, R>

The resulting type after applying the + operator.

fn add(self, other: DualMultivector<T, P, Q, R>) -> DualMultivector<T, P, Q, R>

Performs the + operation.

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

where T: Clone + Float,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where T: Debug + Float,

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

Formats the value using the given formatter.

impl<T, const P: usize, const Q: usize, const R: usize> Mul<DualNumber<T>> for DualMultivector<T, P, Q, R>

where T: Float,

type Output = DualMultivector<T, P, Q, R>

The resulting type after applying the * operator.

fn mul(self, scalar: DualNumber<T>) -> DualMultivector<T, P, Q, R>

Performs the * operation.

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

where T: Float,

type Output = DualMultivector<T, P, Q, R>

The resulting type after applying the - operator.

fn sub(self, other: DualMultivector<T, P, Q, R>) -> DualMultivector<T, P, Q, R>

Performs the - operation.