Posted on Aug 30

From C# to Rust: Porting MathFlow to Create MathCore - A Symbolic Math Library Journey

# From C# to Rust: Building a Symbolic Math Library 🚀

Hey DEV community! Today I want to share my journey of porting a symbolic math library from C# to Rust, and what I learned along the way.

## 📖 The Story

Last year, I built MathFlow - a symbolic math library for C#. It worked great, but I was curious about Rust's performance claims. So I decided to rebuild it as
MathCore in Rust.

The results? Mind-blowing! 🤯

## 🎯 Quick Comparison

🔷 C# (MathFlow) 🦀 Rust (MathCore)

 var expr = MathExpression .Parse("x^2 + 2*x + 1"); var derivative = expr .Differentiate("x"); var result = expr .Evaluate(new { x = 5 }); let expr = MathCore::parse( "x^2 + 2*x + 1" )?; let derivative = MathCore::differentiate( &expr, "x" )?; let result = math.calculate( &expr, &[("x", 5.0)] )?;

⚡ Performance Results

I was shocked by these numbers:

| Operation | C# (MathFlow) | Rust (MathCore) | Difference |
|------------------|---------------|-----------------|----------------|
| Parse Expression | 245 µs | 89 µs | 2.7x faster ✨ |
| Differentiate | 1,230 µs | 456 µs | 2.7x faster ✨ |
| Solve Equation | 890 µs | 234 µs | 3.8x faster 🚀 |
| Memory Usage | 847 MB | 124 MB | 6.8x less 🎯 |

💡 Key Differences I Discovered

1️⃣ Error Handling

 C# Way (Exceptions): try { var result = MathExpression.Parse("invalid"); } catch (ParseException e) { Console.WriteLine($"Oops: {e.Message}"); } Rust Way (Result Type): match MathCore::parse("invalid") { Ok(expr) => println!("Success!"), Err(e) => println!("Oops: {}", e), }

💭 Insight: Rust forces you to handle errors. No more surprise crashes in production!

2️⃣ Memory Management

C#:

✅ Garbage collector handles everything
❌ Random GC pauses
❌ Unpredictable performance

Rust:

✅ Predictable performance
✅ No GC pauses
❌ Must think about ownership

3️⃣ Real-World Example

Let's solve a physics problem - projectile motion with air resistance:

 // Calculate trajectory var equation = @" y = v0*sin(θ)*t - 0.5*g*t^2 "; var solver = new MathEngine(); var trajectory = solver .Parse(equation) .Substitute(new { v0 = 100, θ = Math.PI/4, g = 9.81 }); // Calculate trajectory let equation = "  y = v0*sin(θ)*t - 0.5*g*t^2 ";  let math = MathCore::new(); let trajectory = math .calculate(equation, &[ ("v0", 100.0), ("θ", PI/4.0), ("g", 9.81), ])?;

🎨 Architecture Evolution

From OOP to Functional

 C# (Object-Oriented): public abstract class Expression { public abstract double Evaluate(); } public class AddExpr : Expression { private Expression left, right; public override double Evaluate() { return left.Evaluate() + right.Evaluate(); } }

 Rust (Algebraic Data Types): enum Expr { Number(f64), Add(Box<Expr>, Box<Expr>), } fn evaluate(expr: &Expr) -> f64 { match expr { Expr::Number(n) => *n, Expr::Add(l, r) => evaluate(l) + evaluate(r), } }

🎯 Why this matters: Pattern matching eliminated entire class hierarchies!

🚀 Cool Features in Both

Features Comparison

| Feature | MathFlow (C#) | MathCore (Rust) |
|--------------------------|---------------|-----------------|
| Symbolic Differentiation | ✅ | ✅ |
| Equation Solving | ✅ | ✅ |
| Matrix Operations | ✅ | ✅ |
| Complex Numbers | ✅ | ✅ |
| Arbitrary Precision | ✅ | ✅ |
| Parallel Computation | ✅ Tasks | ✅ Rayon |
| WASM Support | ⏳ Coming | ✅ Ready |
| FFT | ✅ | ✅ |

📦 Try Them Out!

For .NET Developers:

dotnet add package MathFlow

 using MathFlow; var math = new MathEngine(); var derivative = math.Differentiate("sin(x^2)", "x"); Console.WriteLine(derivative); // Output: 2*x*cos(x^2)

For Rust Developers:

cargo add mathcore

 use mathcore::MathCore; fn main() { let derivative = MathCore::differentiate("sin(x^2)", "x").unwrap(); println!("{}", derivative); // Output: 2*x*cos(x^2) }