mathcompile 0.1.2

High-performance symbolic mathematics with final tagless design, egglog optimization, and Rust hot-loading compilation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use mathcompile::final_tagless::{ASTEval, ASTMathExpr, DirectEval};

#[cfg(feature = "optimization")]
use mathcompile::egglog_integration::EgglogOptimizer;

fn main() {
    println!("=== Debug Egglog Optimization ===\n");

    #[cfg(feature = "optimization")]
    {
        let mut optimizer = EgglogOptimizer::new().unwrap();

        // Test 1: Simple x + 0 optimization
        println!("1. Testing x + 0 optimization:");
        let expr1 = ASTEval::add(ASTEval::var_by_name("x"), ASTEval::constant(0.0));
        println!("   Original expression: {expr1:?}");

        match optimizer.optimize(&expr1) {
            Ok(optimized) => {
                println!("   ✅ Optimization succeeded!");
                println!("   Optimized expression: {optimized:?}");
                let original_val = DirectEval::eval_with_vars(&expr1, &[5.0]);
                let optimized_val = DirectEval::eval_with_vars(&optimized, &[5.0]);
                println!("   Values: Original = {original_val}, Optimized = {optimized_val}");
                println!(
                    "   Structurally different: {}",
                    !expressions_equal(&expr1, &optimized)
                );
            }
            Err(e) => {
                println!("   ⚠️  Optimization failed: {e}");
            }
        }

        // Test 2: Simple x * 0 optimization
        println!("\n2. Testing x * 0 optimization:");
        let expr2 = ASTEval::mul(ASTEval::var_by_name("x"), ASTEval::constant(0.0));
        println!("   Original expression: {expr2:?}");

        match optimizer.optimize(&expr2) {
            Ok(optimized) => {
                println!("   ✅ Optimization succeeded!");
                println!("   Optimized expression: {optimized:?}");
                let original_val = DirectEval::eval_with_vars(&expr2, &[5.0]);
                let optimized_val = DirectEval::eval_with_vars(&optimized, &[5.0]);
                println!("   Values: Original = {original_val}, Optimized = {optimized_val}");
                println!(
                    "   Structurally different: {}",
                    !expressions_equal(&expr2, &optimized)
                );
            }
            Err(e) => {
                println!("   ⚠️  Optimization failed: {e}");
            }
        }

        // Test 3: x * 1 optimization
        println!("\n3. Testing x * 1 optimization:");
        let expr3 = ASTEval::mul(ASTEval::var_by_name("x"), ASTEval::constant(1.0));
        println!("   Original expression: {expr3:?}");

        match optimizer.optimize(&expr3) {
            Ok(optimized) => {
                println!("   ✅ Optimization succeeded!");
                println!("   Optimized expression: {optimized:?}");
                let original_val = DirectEval::eval_with_vars(&expr3, &[7.0]);
                let optimized_val = DirectEval::eval_with_vars(&optimized, &[7.0]);
                println!("   Values: Original = {original_val}, Optimized = {optimized_val}");
                println!(
                    "   Structurally different: {}",
                    !expressions_equal(&expr3, &optimized)
                );
            }
            Err(e) => {
                println!("   ⚠️  Optimization failed: {e}");
            }
        }

        // Test 4: Complex expression optimization
        println!("\n4. Testing complex expression optimization:");
        let expr4 = ASTEval::add(
            ASTEval::mul(ASTEval::var_by_name("x"), ASTEval::constant(1.0)),
            ASTEval::mul(ASTEval::constant(0.0), ASTEval::var_by_name("y")),
        );
        println!("   Original expression: {expr4:?}");

        match optimizer.optimize(&expr4) {
            Ok(optimized) => {
                println!("   ✅ Optimization succeeded!");
                println!("   Optimized expression: {optimized:?}");
                let original_val = DirectEval::eval_with_vars(&expr4, &[5.0, 3.0]);
                let optimized_val = DirectEval::eval_with_vars(&optimized, &[5.0, 3.0]);
                println!("   Values: Original = {original_val}, Optimized = {optimized_val}");
                println!(
                    "   Structurally different: {}",
                    !expressions_equal(&expr4, &optimized)
                );
            }
            Err(e) => {
                println!("   ⚠️  Optimization failed: {e}");
            }
        }

        // Test 5: Algebraic simplification
        println!("\n5. Testing algebraic simplification:");
        let expr5 = ASTEval::add(
            ASTEval::add(ASTEval::var_by_name("x"), ASTEval::var_by_name("x")),
            ASTEval::constant(0.0),
        );
        println!("   Original expression: {expr5:?}");

        match optimizer.optimize(&expr5) {
            Ok(optimized) => {
                println!("   ✅ Optimization succeeded!");
                println!("   Optimized expression: {optimized:?}");
                let original_val = DirectEval::eval_with_vars(&expr5, &[4.0]);
                let optimized_val = DirectEval::eval_with_vars(&optimized, &[4.0]);
                println!("   Values: Original = {original_val}, Optimized = {optimized_val}");
                println!(
                    "   Structurally different: {}",
                    !expressions_equal(&expr5, &optimized)
                );
            }
            Err(e) => {
                println!("   ⚠️  Optimization failed: {e}");
            }
        }
    }

    #[cfg(not(feature = "optimization"))]
    {
        println!("Egglog optimization feature is not enabled.");
        println!("Run with: cargo run --example debug_egglog --features optimization");
    }
}

/// Helper function to check if two expressions are structurally equal
fn expressions_equal(
    expr1: &mathcompile::final_tagless::ASTRepr<f64>,
    expr2: &mathcompile::final_tagless::ASTRepr<f64>,
) -> bool {
    format!("{expr1:?}") == format!("{expr2:?}")
}