Trait MathExpr

pub trait MathExpr {
    type Repr<T>;

    // Required methods
    fn constant<T: NumericType>(value: T) -> Self::Repr<T>;
    fn var<T: NumericType>(name: &str) -> Self::Repr<T>;
    fn var_by_index<T: NumericType>(index: usize) -> Self::Repr<T>;
    fn add<L, R, Output>(
        left: Self::Repr<L>,
        right: Self::Repr<R>,
    ) -> Self::Repr<Output>
       where L: NumericType + Add<R, Output = Output>,
             R: NumericType,
             Output: NumericType;
    fn sub<L, R, Output>(
        left: Self::Repr<L>,
        right: Self::Repr<R>,
    ) -> Self::Repr<Output>
       where L: NumericType + Sub<R, Output = Output>,
             R: NumericType,
             Output: NumericType;
    fn mul<L, R, Output>(
        left: Self::Repr<L>,
        right: Self::Repr<R>,
    ) -> Self::Repr<Output>
       where L: NumericType + Mul<R, Output = Output>,
             R: NumericType,
             Output: NumericType;
    fn div<L, R, Output>(
        left: Self::Repr<L>,
        right: Self::Repr<R>,
    ) -> Self::Repr<Output>
       where L: NumericType + Div<R, Output = Output>,
             R: NumericType,
             Output: NumericType;
    fn pow<T: NumericType + Float>(
        base: Self::Repr<T>,
        exp: Self::Repr<T>,
    ) -> Self::Repr<T>;
    fn neg<T: NumericType + Neg<Output = T>>(
        expr: Self::Repr<T>,
    ) -> Self::Repr<T>;
    fn ln<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>;
    fn exp<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>;
    fn sqrt<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>;
    fn sin<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>;
    fn cos<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>;
}

Core trait for mathematical expressions using Generic Associated Types (GATs) This follows the final tagless approach where the representation type is parameterized and works with generic numeric types including AD types

Required Associated Types

type Repr<T>

The representation type parameterized by the value type

Required Methods

fn constant<T: NumericType>(value: T) -> Self::Repr<T>

Create a constant value

fn var<T: NumericType>(name: &str) -> Self::Repr<T>

Create a variable reference by name (registers variable automatically)

fn var_by_index<T: NumericType>(index: usize) -> Self::Repr<T>

Create a variable reference by index (for performance-critical code)

fn add<L, R, Output>( left: Self::Repr<L>, right: Self::Repr<R>, ) -> Self::Repr<Output>

where L: NumericType + Add<R, Output = Output>, R: NumericType, Output: NumericType,

Addition operation

fn sub<L, R, Output>( left: Self::Repr<L>, right: Self::Repr<R>, ) -> Self::Repr<Output>

where L: NumericType + Sub<R, Output = Output>, R: NumericType, Output: NumericType,

Subtraction operation

fn mul<L, R, Output>( left: Self::Repr<L>, right: Self::Repr<R>, ) -> Self::Repr<Output>

where L: NumericType + Mul<R, Output = Output>, R: NumericType, Output: NumericType,

Multiplication operation

fn div<L, R, Output>( left: Self::Repr<L>, right: Self::Repr<R>, ) -> Self::Repr<Output>

where L: NumericType + Div<R, Output = Output>, R: NumericType, Output: NumericType,

Division operation

fn pow<T: NumericType + Float>( base: Self::Repr<T>, exp: Self::Repr<T>, ) -> Self::Repr<T>

Power operation

fn neg<T: NumericType + Neg<Output = T>>(expr: Self::Repr<T>) -> Self::Repr<T>

Negation operation

fn ln<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>

Natural logarithm

fn exp<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>

Exponential function

fn sqrt<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>

Square root

fn sin<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>

Sine function

fn cos<T: NumericType + Float>(expr: Self::Repr<T>) -> Self::Repr<T>

Cosine function

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl MathExpr for ASTEval

For compatibility with the main MathExpr trait, we provide a limited implementation that works only with f64 types

type Repr<T> = ASTRepr<T>

impl MathExpr for DirectEval

type Repr<T> = T

impl MathExpr for PrettyPrint

type Repr<T> = String