use dslcompile::prelude::*;

// Create mathematical expressions with natural syntax
let math = DynamicContext::new();
let x = math.var();
let expr = &x * &x + 2.0 * &x + 1.0; // x² + 2x + 1

// Direct evaluation
let result = math.eval(&expr, &[3.0]); // x = 3.0
assert_eq!(result, 16.0); // 9 + 6 + 1 = 16

// Symbolic optimization (optional for performance)
let mut optimizer = SymbolicOptimizer::new()?;
let optimized = optimizer.optimize(&expr.into())?;
let optimized_result = optimized.eval_with_vars(&[3.0]);
assert_eq!(optimized_result, 16.0);

use dslcompile::prelude::*;

let math = DynamicContext::new();
let x = math.var();

// Original: (x + 1)²
let expr = (&x + math.constant(1.0)).pow(math.constant(2.0));

// Optimize symbolically
let mut optimizer = SymbolicOptimizer::new()?;
let optimized = optimizer.optimize(&expr.into())?;

// Results in optimized form: x² + 2x + 1
// Operation count: 2 → 3 (expanded but optimized for evaluation)
// Execution speedup: 1.2-50x depending on input complexity

use dslcompile::prelude::*;

let math = DynamicContext::new();
let x = math.var();
let y = math.var();

// Complex expression with optimization opportunities:
// ln(exp(x)) + (y + 0) * 1 + sin²(x) + cos²(x) + exp(ln(y)) - 0
let complex_expr = x.clone().exp().ln()                    // ln(exp(x)) = x
    + (&y + math.constant(0.0)) * math.constant(1.0)      // (y + 0) * 1 = y  
    + x.clone().sin().pow(math.constant(2.0))              // sin²(x)
    + x.clone().cos().pow(math.constant(2.0))              // cos²(x)
    + y.clone().ln().exp()                                 // exp(ln(y)) = y
    - math.constant(0.0);                                  // - 0

let mut optimizer = SymbolicOptimizer::new()?;
let optimized = optimizer.optimize(&complex_expr.into())?;

// Optimizes to: x + y + 1 + y = x + 2y + 1
// Operation count: 17 → 3 (82% reduction)
// Execution speedup: 7.3-87.9x

use dslcompile::prelude::*;

// Generate optimized Rust code
let codegen = RustCodeGenerator::new();
let rust_code = codegen.generate_function(&optimized_expr, "my_function")?;

// Compile and load dynamically
let compiler = RustCompiler::new();
let compiled_func = compiler.compile_and_load(&rust_code, "my_function")?;

// Execute with native performance
let result = compiled_func.call_two_vars(2.5, 3.7)?;

#[target_feature(enable = "avx2")]
#[no_mangle]
pub extern "C" fn my_function(var_0: f64, var_1: f64, var_2: f64) -> f64 {
    return (((var_1 + var_2) + (((var_1).sin() * (var_1).sin()) + 
             ((var_1).cos() * (var_1).cos()))) + var_2);
}

use dslcompile::prelude::*;

let math = DynamicContext::new();
let x = math.var();
let y = math.var();

// Natural mathematical syntax
let expr = &x * &x + 2.0 * &x + &y;
let result = math.eval(&expr, &[3.0, 1.0]); // x=3, y=1 → 16

// Transcendental functions
let complex = x.clone().sin() * y.exp() + (x.clone() * &x + 1.0).ln();
let complex_result = math.eval(&complex, &[1.0, 2.0]);

// Mathematical summations with optimization
let sum_result = math.sum(1..=10, |i| i * math.constant(2.0))?; // Σ(2i) = 110

use dslcompile::prelude::*;

let math = MathBuilder::new();
let x = math.var();
let f = math.poly(&[1.0, 2.0, 1.0], &x); // 1 + 2x + x²

// Convert to optimized AST
let optimized_f = math.optimize(&f)?;

// Compute function and derivatives symbolically
let mut ad = SymbolicAD::new()?;
let result = ad.compute_with_derivatives(&optimized_f)?;

println!("f(x) = 1 + 2x + x²");
println!("f'(x) = 2 + 2x (computed symbolically)");

use dslcompile::prelude::*;

let mut simplifier = SummationSimplifier::new();
let range = IntRange::new(1, 10);

// Arithmetic series: Σ(i=1 to 10) i = 55
let function = ASTFunction::new("i", ASTRepr::Variable(0));
let result = simplifier.simplify_finite_sum(&range, &function)?;

if let Some(closed_form) = &result.closed_form {
    let value = closed_form.eval_with_vars(&[]);
    assert_eq!(value, 55.0);
}