Enum ASTRepr

pub enum ASTRepr<T> {
    Constant(T),
    Variable(usize),
    Add(Box<ASTRepr<T>>, Box<ASTRepr<T>>),
    Sub(Box<ASTRepr<T>>, Box<ASTRepr<T>>),
    Mul(Box<ASTRepr<T>>, Box<ASTRepr<T>>),
    Div(Box<ASTRepr<T>>, Box<ASTRepr<T>>),
    Pow(Box<ASTRepr<T>>, Box<ASTRepr<T>>),
    Neg(Box<ASTRepr<T>>),
    Ln(Box<ASTRepr<T>>),
    Exp(Box<ASTRepr<T>>),
    Sqrt(Box<ASTRepr<T>>),
    Sin(Box<ASTRepr<T>>),
    Cos(Box<ASTRepr<T>>),
}

JIT compilation representation for mathematical expressions

This enum represents mathematical expressions in a form suitable for JIT compilation using Cranelift. Each variant corresponds to a mathematical operation that can be compiled to native machine code.

Performance Note

Variables are referenced by index for optimal performance with DirectEval, using vector indexing instead of string lookups:

use mathcompile::final_tagless::{ASTRepr, DirectEval};

// Efficient: uses vector indexing
let expr = ASTRepr::Add(
    Box::new(ASTRepr::Variable(0)), // x
    Box::new(ASTRepr::Variable(1)), // y
);
let result = DirectEval::eval_with_vars(&expr, &[2.0, 3.0]);
assert_eq!(result, 5.0);

Variants

Constant(T)

Constant value

Variable(usize)

Variable reference by index (efficient for evaluation)

Add(Box<ASTRepr<T>>, Box<ASTRepr<T>>)

Addition of two expressions

Sub(Box<ASTRepr<T>>, Box<ASTRepr<T>>)

Subtraction of two expressions

Mul(Box<ASTRepr<T>>, Box<ASTRepr<T>>)

Multiplication of two expressions

Div(Box<ASTRepr<T>>, Box<ASTRepr<T>>)

Division of two expressions

Pow(Box<ASTRepr<T>>, Box<ASTRepr<T>>)

Power operation

Neg(Box<ASTRepr<T>>)

Negation

Ln(Box<ASTRepr<T>>)

Natural logarithm

Exp(Box<ASTRepr<T>>)

Exponential function

Sqrt(Box<ASTRepr<T>>)

Square root

Sin(Box<ASTRepr<T>>)

Sine function

Cos(Box<ASTRepr<T>>)

Cosine function

Implementations

impl<T> ASTRepr<T>

pub fn count_operations(&self) -> usize

Count the total number of operations in the expression tree

pub fn variable_index(&self) -> Option<usize>

Get the variable index if this is a variable, otherwise None

impl<T> ASTRepr<T>

pub fn count_summation_operations(&self) -> usize

Add summation support to the AST representation

These variants would be added to the enum in a complete implementation:

• SumFinite(Box<ASTRepr>, Box<ASTRepr<ASTFunction>>)
• SumInfinite(Box<ASTRepr>, Box<ASTRepr<ASTFunction>>)
• SumTelescoping(Box<ASTRepr>, Box<ASTRepr<ASTFunction>>)
• Range(i64, i64)
• Function(String, Box<ASTRepr>) Placeholder for future summation operation counting

impl<T> ASTRepr<T>

where T: NumericType,

Additional convenience methods for ASTRepr<T> with generic types

pub fn pow(self, exp: ASTRepr<T>) -> ASTRepr<T>

where T: Float,

Power operation with natural syntax

pub fn pow_ref(&self, exp: &ASTRepr<T>) -> ASTRepr<T>

where T: Float,

Power operation with reference

pub fn ln(self) -> ASTRepr<T>

where T: Float,

Natural logarithm

pub fn ln_ref(&self) -> ASTRepr<T>

where T: Float,

Natural logarithm with reference

pub fn exp(self) -> ASTRepr<T>

where T: Float,

Exponential function

pub fn exp_ref(&self) -> ASTRepr<T>

where T: Float,

Exponential function with reference

pub fn sqrt(self) -> ASTRepr<T>

where T: Float,

Square root

pub fn sqrt_ref(&self) -> ASTRepr<T>

where T: Float,

Square root with reference

pub fn sin(self) -> ASTRepr<T>

where T: Float,

Sine function

pub fn sin_ref(&self) -> ASTRepr<T>

where T: Float,

Sine function with reference

pub fn cos(self) -> ASTRepr<T>

where T: Float,

Cosine function

pub fn cos_ref(&self) -> ASTRepr<T>

where T: Float,

Cosine function with reference

Trait Implementations

impl<T> Add<&ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Add<Output = T>,

Addition with references

type Output = ASTRepr<T>

The resulting type after applying the + operator.

fn add(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the + operation.

impl<T> Add<&ASTRepr<T>> for ASTRepr<T>

where T: NumericType + Add<Output = T>,

type Output = ASTRepr<T>

The resulting type after applying the + operator.

fn add(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the + operation.

impl<T> Add<ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Add<Output = T>,

Addition with mixed references

type Output = ASTRepr<T>

The resulting type after applying the + operator.

fn add(self, rhs: ASTRepr<T>) -> Self::Output

Performs the + operation.

impl<T> Add for ASTRepr<T>

where T: NumericType + Add<Output = T>,

Addition operator overloading for ASTRepr<T>

type Output = ASTRepr<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for ASTRepr<T>

fn clone(&self) -> ASTRepr<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ASTRepr<T>

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

Formats the value using the given formatter.

impl<T> Div<&ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Div<Output = T>,

Division with references

type Output = ASTRepr<T>

The resulting type after applying the / operator.

fn div(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the / operation.

impl<T> Div<&ASTRepr<T>> for ASTRepr<T>

where T: NumericType + Div<Output = T>,

type Output = ASTRepr<T>

The resulting type after applying the / operator.

fn div(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the / operation.

impl<T> Div<ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Div<Output = T>,

Division with mixed references

type Output = ASTRepr<T>

The resulting type after applying the / operator.

fn div(self, rhs: ASTRepr<T>) -> Self::Output

Performs the / operation.

impl<T> Div for ASTRepr<T>

where T: NumericType + Div<Output = T>,

Division operator overloading for ASTRepr<T>

type Output = ASTRepr<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T> Mul<&ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Mul<Output = T>,

Multiplication with references

type Output = ASTRepr<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<&ASTRepr<T>> for ASTRepr<T>

where T: NumericType + Mul<Output = T>,

type Output = ASTRepr<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Mul<Output = T>,

Multiplication with mixed references

type Output = ASTRepr<T>

The resulting type after applying the * operator.

fn mul(self, rhs: ASTRepr<T>) -> Self::Output

Performs the * operation.

impl<T> Mul for ASTRepr<T>

where T: NumericType + Mul<Output = T>,

Multiplication operator overloading for ASTRepr<T>

type Output = ASTRepr<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> Neg for &ASTRepr<T>

where T: NumericType + Neg<Output = T>,

Negation with references

type Output = ASTRepr<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Neg for ASTRepr<T>

where T: NumericType + Neg<Output = T>,

Negation operator overloading for ASTRepr<T>

type Output = ASTRepr<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq for ASTRepr<T>

fn eq(&self, other: &ASTRepr<T>) -> 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<T> Sub<&ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Sub<Output = T>,

Subtraction with references

type Output = ASTRepr<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<&ASTRepr<T>> for ASTRepr<T>

where T: NumericType + Sub<Output = T>,

type Output = ASTRepr<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &ASTRepr<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<ASTRepr<T>> for &ASTRepr<T>

where T: NumericType + Sub<Output = T>,

Subtraction with mixed references

type Output = ASTRepr<T>

The resulting type after applying the - operator.

fn sub(self, rhs: ASTRepr<T>) -> Self::Output

Performs the - operation.

impl<T> Sub for ASTRepr<T>

where T: NumericType + Sub<Output = T>,

Subtraction operator overloading for ASTRepr<T>

type Output = ASTRepr<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> StructuralPartialEq for ASTRepr<T>