MathExpr compilation

Author: miroiu

README.md

@@ -1,4 +1,4 @@
-> V3 README can be found here: https://github.com/miroiu/string-math/tree/release-3.0.0
+> V3 README can be found here: <https://github.com/miroiu/string-math/tree/release-3.0.0>
 
 # String Math [![NuGet](https://img.shields.io/nuget/v/StringMath?style=flat-square&logo=nuget)](https://www.nuget.org/packages/StringMath/) [![Downloads](https://img.shields.io/nuget/dt/StringMath?label=downloads&style=flat-square&logo=nuget)](https://www.nuget.org/packages/StringMath) ![.NET](https://img.shields.io/static/v1?label=%20&message=Framework%204.6.1%20to%20NET%206&color=5C2D91&style=flat-square&logo=.net) ![](https://img.shields.io/static/v1?label=%20&message=documentation&color=yellow&style=flat-square)
 
@@ -57,19 +57,26 @@ double result2 = "{PI} + 1".Eval(); // 4.1415926535897931
 
 ```csharp
 var expr = "{a} + {b} + {PI}".ToMathExpr();
-var variables = expr.Variables;	// { "a", "b", "PI" }
+var variables = expr.Variables; // { "a", "b", "PI" }
 var localVariables = expr.LocalVariables; // { "a", "b" }
 ```
 
+### Compilation
+
+```csharp
+Func<double, double> fn = "{a} + 2".ToMathExpr().Compile("a");
+double result = fn(5); // 7
+```
+
 ### Conditional substitution
 
 ```csharp
 MathExpr expr = "1 / {a}".Substitute("a", 1);
 
 double temp = expr.Result; // 1
 
-if (someCondition) 	// true
-	expr.Substitute("a", 2);
+if (someCondition)  // true
+ expr.Substitute("a", 2);
 
 double final = expr.Result; // 0.5
 ```
@@ -88,7 +95,7 @@ double result = "1 + 2 + 3".Eval(expr.Context);
 ### Custom math context
 
 ```csharp
-var context = new MathContext();	// new MathContext(MathContext.Default); // to inherit from global
+var context = new MathContext(); // new MathContext(MathContext.Default); // to inherit from global
 context.RegisterBinary("+", (a, b) => Math.Pow(a, b));
 
 MathExpr expr = new MathExpr("{PI} + 1", context);

StringMath.Tests/CalculatorTests.cs StringMath.Tests/MathExprTests.csStringMath.Tests/CalculatorTests.cs renamed to StringMath.Tests/MathExprTests.cs

@@ -4,7 +4,7 @@
 namespace StringMath.Tests
 {
     [TestFixture]
-    internal class CalculatorTests
+    internal class MathExprTests
     {
         [SetUp]
         public void Setup()
@@ -278,5 +278,46 @@ public void Evaluate_Custom_Context()
             double result = "1 + 2 + 3".Eval(context);
             Assert.AreEqual(1, result);
         }
+
+        [Test]
+        [TestCase("1 + 5", 6)]
+        [TestCase("1 + -5", -4)]
+        [TestCase("2 * (abs(-5) + 1)", 12)]
+        public void Compile(string input, double expected)
+        {
+            Func<double> fn = input.ToMathExpr().Compile();
+            double result = fn();
+
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        [TestCase("1 + {a}", new[] { "a" }, new[] { 1d }, 2)]
+        public void Compile1(string input, string[] paramsOrder, double[] paramsValues, double expected)
+        {
+            Func<double, double> fn = input.ToMathExpr().Compile(paramsOrder[0]);
+            double result = fn(paramsValues[0]);
+
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        [TestCase("(1 + {a}) * {b}", new[] { "b", "a" }, new[] { 2d, 3d }, 8)]
+        [TestCase("(1 + {b}) * {a}", new[] { "b", "a" }, new[] { 2d, 3d }, 9)]
+        public void Compile2(string input, string[] paramsOrder, double[] paramsValues, double expected)
+        {
+            Func<double, double, double> fn = input.ToMathExpr().Compile(paramsOrder[0], paramsOrder[1]);
+            double result = fn(paramsValues[0], paramsValues[1]);
+
+            Assert.AreEqual(expected, result);
+        }
+
+        [Test]
+        public void Compile1_Throws_Missing_Variable()
+        {
+            MathException ex = Assert.Throws<MathException>(() => "1 + {a}".ToMathExpr().Compile("b"));
+
+            Assert.AreEqual(MathException.ErrorCode.UNEXISTING_VARIABLE, ex.Code);
+        }
     }
 }

StringMath/MathExpr.cs

@@ -107,6 +107,54 @@ public MathExpr Substitute(string name, double value)
             return this;
         }
 
+        /// <summary>Compiles a <see cref="MathExpr"/> into a delegate.</summary>
+        /// <returns>A type safe delegate.</returns>
+        public Func<double> Compile()
+        {
+            var exp = new CompileExpression().Compile<Func<IMathContext, double>>(Expression).Compile();
+            return () => exp(Context);
+        }
+
+        /// <summary>Compiles a <see cref="MathExpr"/> into a delegate.</summary>
+        /// <returns>A type safe delegate.</returns>
+        public Func<double, double> Compile(string var)
+        {
+            var exp = new CompileExpression().Compile<Func<IMathContext, double, double>>(Expression, var).Compile();
+            return (double x) => exp(Context, x);
+        }
+
+        /// <summary>Compiles a <see cref="MathExpr"/> into a delegate.</summary>
+        /// <returns>A type safe delegate.</returns>
+        public Func<double, double, double> Compile(string var1, string var2)
+        {
+            var exp = new CompileExpression().Compile<Func<IMathContext, double, double, double>>(Expression, var1, var2).Compile();
+            return (x, y) => exp(Context, x, y);
+        }
+
+        /// <summary>Compiles a <see cref="MathExpr"/> into a delegate.</summary>
+        /// <returns>A type safe delegate.</returns>
+        public Func<double, double, double, double> Compile(string var1, string var2, string var3)
+        {
+            var exp = new CompileExpression().Compile<Func<IMathContext, double, double, double, double>>(Expression, var1, var2, var3).Compile();
+            return (x, y, z) => exp(Context, x, y, z);
+        }
+
+        /// <summary>Compiles a <see cref="MathExpr"/> into a delegate.</summary>
+        /// <returns>A type safe delegate.</returns>
+        public Func<double, double, double, double, double> Compile(string var1, string var2, string var3, string var4)
+        {
+            var exp = new CompileExpression().Compile<Func<IMathContext, double, double, double, double, double>>(Expression, var1, var2, var3, var4).Compile();
+            return (x, y, z, w) => exp(Context, x, y, z, w);
+        }
+
+        /// <summary>Compiles a <see cref="MathExpr"/> into a delegate.</summary>
+        /// <returns>A type safe delegate.</returns>
+        public Func<double, double, double, double, double, double> Compile(string var1, string var2, string var3, string var4, string var5)
+        {
+            var exp = new CompileExpression().Compile<Func<IMathContext, double, double, double, double, double, double>>(Expression, var1, var2, var3, var4, var5).Compile();
+            return (x, y, z, w, q) => exp(Context, x, y, z, w, q);
+        }
+
         /// <summary>Converts a string to a <see cref="MathExpr"/>.</summary>
         /// <param name="value">The value to convert.</param>
         public static implicit operator MathExpr(string value) => new MathExpr(value);

StringMath/StringMath.csproj

@@ -12,8 +12,8 @@ Supports variables and user defined operators.</Description>
     <PackageProjectUrl>https://github.com/miroiu/string-math</PackageProjectUrl>
     <RepositoryUrl>https://github.com/miroiu/string-math</RepositoryUrl>
     <PackageTags>expression-evaluator calculator string-math math string-calculator user-defined-operators operators custom-operators</PackageTags>
-    <Version>4.0.0</Version>
-    <PackageReleaseNotes>Refactored everything and added support for .NET 5 and .NET 6</PackageReleaseNotes>
+    <Version>4.1.0</Version>
+    <PackageReleaseNotes>Added math expression compliation</PackageReleaseNotes>
     <PackageLicenseFile></PackageLicenseFile>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Nullable>enable</Nullable>

StringMath/Visitors/CompileExpression.cs

@@ -0,0 +1,63 @@
+using SM = StringMath.Expressions;
+using System;
+using System.Linq.Expressions;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace StringMath
+{
+    internal class CompileExpression
+    {
+        private static readonly ParameterExpression _contextParam = Expression.Parameter(typeof(IMathContext), "ctx");
+        private Dictionary<string, ParameterExpression> _variables = new Dictionary<string, ParameterExpression>();
+
+        public Expression<T> Compile<T>(SM.IExpression expression, params string[] variables)
+        {
+            _variables = variables.ToDictionary(var => var, var => Expression.Parameter(typeof(double), var));
+            var args = new List<ParameterExpression>(1 + variables.Length)
+            {
+                _contextParam
+            };
+            args.AddRange(_variables.Values);
+
+            var result = Convert(expression);
+            return Expression.Lambda<T>(result, args);
+        }
+
+        public Expression Convert(SM.IExpression expression)
+        {
+            Expression result = expression switch
+            {
+                SM.BinaryExpression binaryExpr => ConvertBinaryExpr(binaryExpr),
+                SM.ConstantExpression constantExpr => ConvertConstantExpr(constantExpr),
+                SM.UnaryExpression unaryExpr => ConvertUnaryExpr(unaryExpr),
+                SM.VariableExpression variableExpr => ConvertVariableExpr(variableExpr),
+                _ => throw new NotImplementedException($"'{expression?.GetType().Name}' Convertor is not implemented.")
+            };
+
+            return result;
+        }
+
+        public Expression ConvertVariableExpr(SM.VariableExpression variableExpr)
+        {
+            if (!_variables.TryGetValue(variableExpr.Name, out var result))
+                throw MathException.MissingVariable(variableExpr.Name);
+
+            return result;
+        }
+
+        public Expression ConvertConstantExpr(SM.ConstantExpression constantExpr) => Expression.Constant(constantExpr.Value);
+
+        public Expression ConvertBinaryExpr(SM.BinaryExpression binaryExpr) =>
+            Expression.Call(_contextParam,
+                nameof(IMathContext.EvaluateBinary),
+                null,
+                Expression.Constant(binaryExpr.OperatorName), Convert(binaryExpr.Left), Convert(binaryExpr.Right));
+
+        public Expression ConvertUnaryExpr(SM.UnaryExpression unaryExpr) =>
+            Expression.Call(_contextParam,
+                nameof(IMathContext.EvaluateUnary),
+                null,
+                Expression.Constant(unaryExpr.OperatorName), Convert(unaryExpr.Operand));
+    }
+}