Crate mathcompile

MathCompile: High-Performance Mathematical Expression Compilation

MathCompile provides a three-layer optimization strategy for mathematical expressions:

1. Final Tagless Approach: Type-safe expression building with multiple interpreters
2. Symbolic Optimization: Algebraic simplification using egglog
3. Compilation Backends: Rust hot-loading (primary) and optional Cranelift JIT

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    Final Tagless Layer                     │
│  (Expression Building & Type Safety)                       │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────────────┐
│                 Symbolic Optimization                       │
│  (Algebraic Simplification & Rewrite Rules)                │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────────────┐
│                 Compilation Backends                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │    Rust     │  │  Cranelift  │  │  Future Backends    │  │
│  │ Hot-Loading │  │     JIT     │  │   (LLVM, etc.)      │  │
│  │ (Primary)   │  │ (Optional)  │  │                     │  │
│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Re-exports

pub use error::MathCompileError;

pub use error::Result;

pub use expr::Expr;

pub use final_tagless::ASTEval;

pub use final_tagless::ASTMathExpr;

pub use final_tagless::ASTRepr;

pub use final_tagless::DirectEval;

pub use final_tagless::MathExpr;

pub use final_tagless::NumericType;

pub use final_tagless::PrettyPrint;

pub use final_tagless::StatisticalExpr;

pub use symbolic::CompilationApproach;

pub use symbolic::CompilationStrategy;

pub use symbolic::OptimizationConfig;

pub use symbolic::SymbolicOptimizer;

pub use backends::CompiledRustFunction;

pub use backends::RustCodeGenerator;

pub use backends::RustCompiler;

pub use backends::RustOptLevel;

pub use ergonomics::MathBuilder;

pub use ergonomics::presets;

pub use symbolic_ad::FunctionWithDerivatives;

pub use symbolic_ad::SymbolicAD;

pub use symbolic_ad::SymbolicADConfig;

pub use symbolic_ad::SymbolicADStats;

pub use summation::SumResult;

pub use summation::SummationConfig;

pub use summation::SummationPattern;

pub use summation::SummationSimplifier;

pub use anf::ANFAtom;

pub use anf::ANFCodeGen;

pub use anf::ANFComputation;

pub use anf::ANFConverter;

pub use anf::ANFExpr;

pub use anf::ANFVarGen;

pub use anf::VarRef;

pub use anf::convert_to_anf;

pub use anf::generate_rust_code;

pub use pretty::pretty_anf;

pub use pretty::pretty_ast;

Modules

anf

A-Normal Form (ANF) Intermediate Representation

ast_utils

AST Utility Functions

backends

Compilation Backends for MathCompile

egglog_integration

Egglog Integration for Symbolic Optimization

ergonomics

Ergonomic API for Mathematical Expression Building

error

Error types for MathCompile

expr

Ergonomic wrapper for final tagless expressions with operator overloading

final_tagless

Final Tagless Approach for Symbolic Mathematical Expressions

interval_domain

Interval-based domain analysis with endpoint specification Interval-Based Domain Analysis

power_utils

Power Optimization Utilities

prelude

Prelude module for convenient imports

pretty

Pretty-printers for ASTRepr and ANFExpr

summation

symbolic

Symbolic optimization using egglog for algebraic simplification

symbolic_ad

Symbolic Automatic Differentiation

transcendental

Optimal rational approximations for transcendental functions

Constants

VERSION

Version information for the MathCompile library