matheval.net 2.0.0

1. About MathEval.NET

MathEval.NET is a mathematical expressions evaluator library written in C#. Allows to evaluate mathematical, boolean, string and datetime expressions Code is written in pure C#, run on the fly. We don't use any third party libraries or packages.

This respository forks from: https://github.com/matheval/expression-evaluator-c-sharp And make many changes:

1. Reconstruct solution, eg. refolder, csharp-like renaming, simply, and more readable.
2. Support more DateTime functions, eg: date, now, year, weekday, adddays...
3. Support more operator, eg: ! !=
4. Support more text function, eg: like
5. Support regist custom function.

[TOC]

2. Installation

Using Package Manager

PM> Install-Package MathEval.NET -Version 4.5.0.0

3. Supported operators, contants, functions

3.1 Supported Operators

3.2 Supported Constants

3.3 Supported conditional statements

3.4 Supported logical functions

3.5 Supported math functions

3.6 Supported math trigonomatric functions

3.7 Supported math statistic functions

3.8 Supported text functions

Text() Example:

3.9 Supported DateTime functions

DateTime functions examples:

var expr = new Expression();
Assert.AreEqual(DateTime.Parse("2020-01-01"),           expr.SetFormular("Date('2020-01-01')").Eval<DateTime>());
Assert.AreEqual(DateTime.Today,                         expr.SetFormular("Today()").Eval<DateTime>());
Assert.AreEqual(DateTime.Now.Day,                       expr.SetFormular("Now()").Eval<DateTime>().Day);
//											            
Assert.AreEqual(DateTime.Today.Year,                    expr.SetFormular("Year(Today())").Eval<int>());
Assert.AreEqual(DateTime.Today.Month,                   expr.SetFormular("Month(Today())").Eval<int>());
Assert.AreEqual(DateTime.Today.Day,                     expr.SetFormular("Day(Today())").Eval<int>());
Assert.AreEqual(DateTime.Today.Hour,                    expr.SetFormular("Hour(Today())").Eval<int>());
Assert.AreEqual(DateTime.Today.Minute,                  expr.SetFormular("Minute(Today())").Eval<int>());
Assert.AreEqual(DateTime.Today.Second,                  expr.SetFormular("Second(Today())").Eval<int>());
Assert.AreEqual(0,                                      expr.SetFormular("Age(Today())").Eval<int>());
Assert.AreEqual(DateTime.Today.DayOfWeek,               expr.SetFormular("Weekday(Today())").Eval<DayOfWeek>());
Assert.AreEqual(DateTime.Today.AddYears(1),             expr.SetFormular("AddYears(Today(), 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Today.AddMonths(1),            expr.SetFormular("AddMonths(Today(), 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Today.AddDays(1),              expr.SetFormular("AddDays(Today(), 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Today.AddHours(1),             expr.SetFormular("AddHours(Today(), 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Today.AddMinutes(1),           expr.SetFormular("AddMinutes(Today(), 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Today.AddSeconds(1),           expr.SetFormular("AddSeconds(Today(), 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Today.AddYears(1),             expr.SetFormular("AddDate(Today(), 1,0,0,0,0,0)").Eval<DateTime>());
//
Assert.AreEqual(2020,                                   expr.SetFormular("Year('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(1,                                      expr.SetFormular("Month('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(1,                                      expr.SetFormular("Day('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(12,                                     expr.SetFormular("Hour('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(0,                                      expr.SetFormular("Minute('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(0,                                      expr.SetFormular("Second('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(DateTime.Now.Year-2020,                 expr.SetFormular("Age('2020-01-01 12:00')").Eval<int>());
Assert.AreEqual(DayOfWeek.Wednesday,                    expr.SetFormular("Weekday('2020-01-01 12:00')").Eval<DayOfWeek>());
Assert.AreEqual(DateTime.Parse("2021-01-01 12:00:00"),  expr.SetFormular("AddYears('2020-01-01 12:00', 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Parse("2020-02-01 12:00:00"),  expr.SetFormular("AddMonths('2020-01-01 12:00', 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Parse("2020-01-02 12:00:00"),  expr.SetFormular("AddDays('2020-01-01 12:00', 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Parse("2020-01-01 13:00:00"),  expr.SetFormular("AddHours('2020-01-01 12:00', 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Parse("2020-01-01 12:01:00"),  expr.SetFormular("AddMinutes('2020-01-01 12:00', 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Parse("2020-01-01 12:00:01"),  expr.SetFormular("AddSeconds('2020-01-01 12:00', 1)").Eval<DateTime>());
Assert.AreEqual(DateTime.Parse("2021-01-01 12:00:00"),  expr.SetFormular("AddDate('2020-01-01 12:00', 1,0,0,0,0,0)").Eval<DateTime>());

4. Custom functions

MathEval.NET support custom functions:

1. Create class to implements IFunction.
2. Regist this class to Expresson object using RegistFunction() or RegistFunctions().
3. OK, run eval().

Examples:

using System;
using System.Collections.Generic;
using Org.MathEval.Common.Functions;
using static Org.MathEval.Common;
public class DateFunctions : IFunction
{
    public List<FunctionDef> GetDefs()
    {
        return new List<FunctionDef> {
            new FunctionDef("now",        typeof(DateTime), 0, null),
            new FunctionDef("year",       typeof(int),      1, typeof(DateTime)),
            new FunctionDef("AddYears",   typeof(DateTime), 2, typeof(DateTime), typeof(int)),
        };
    }
    public object Execute(List<object> args, ExpressionContext dc, string funcName = "")
    {
        var name = funcName.ToLower();
        switch (name)
        {
            case "now":        return DateTime.Now;
            case "year":       return ToDateTime(args[0]).Year;
            case "addyears":   return ToDateTime(args[0]).AddYears(ToInt(args[1]));
        }
        return DateTime.Now;
    }
}

// regist and use this functions
var expression = new Expression().RegistFunction(new DateFunctions());  // regist date functions
var dt = expression.SetFormula("Now()").Eval<DateTime>();               // eval now() function

5. Usage examples

5.1 Basic evaluator

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		var expression = new Expression("(a + b) / 2 ");
		expression.Bind("a", 3);
		expression.Bind("b",5);
		Object value = expression.Eval();
		Console.WriteLine("Result: "+value); //Result: 4
		
	}
}

5.2 Conditional statements

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		Expression expression = new Expression("IF(time>8, (HOUR_SALARY*8) + (HOUR_SALARY*1.25*(time-8)), HOUR_SALARY*time)");
		//bind variable
		expression.Bind("HOUR_SALARY", 10);
		expression.Bind("time", 9);
		//eval
		Decimal salary = expression.Eval<Decimal>();	
		Console.WriteLine(salary); //return 92.5
	}
}

5.3 Validate expression

Expression expression = new Expression("SUM(1,2,3) + true");
List<String> errors = expression.GetError(); 
if(errors.Count > 0)
{
  foreach(String error in errors)
  {
  	Console.WriteLine(error);
  }
}	

5.4 Min, max, sum, avg

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		Expression expr = new Expression("MIN(2,3,16)");
		int min = expr.Eval<int>(); 
		Console.WriteLine(min);// return 2 (min)
		
		expr.SetFomular("Max(2,3,16)");
		int max = expr.Eval<int>(); 
		Console.WriteLine(max);// return 16 (max)
		
		expr.SetFomular("Sum(2,3,16)");
		decimal sum = expr.Eval<decimal>(); 
		Console.WriteLine(sum);// return 21	(sum)
		
		expr.SetFomular("average(2,3,16)");
		decimal average = expr.Eval<decimal>(); 
		Console.WriteLine(average);// return 7 (average)	
	}
}

5.5 Round, floor, ceiling

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		Expression expr = new Expression("ROUND(2.149, 1)");
		Object value = expr.Eval<Decimal>(); 
		Console.WriteLine("ROUND(2.149, 1) = "+value); //return 2.1
		
		expr = new Expression("FLOOR(2.149)");
		value = expr.Eval(); 
		Console.WriteLine("FLOOR(2.149) = "+value); //return 2	
		
		expr = new Expression("FLOOR(3.7,2)");
		value = expr.Eval(); 
		Console.WriteLine("FLOOR(3.7,2) = "+value);	//return 2
		
		expr = new Expression("CEILING(2.149)");
		value = expr.Eval(); 
		Console.WriteLine("CEILING(2.149) = "+value); //return 3
		
		expr = new Expression("CEILING(1.5, 0.1)");
		value = expr.Eval(); 
		Console.WriteLine("CEILING(1.5, 0.1) = "+value); //return 1.5	
	}
}

5.6 Trigonometry

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		Expression expr = new Expression("tan(a)^3-((3*sin(a)-sin(3*a))/(3*cos(a)+cos(3*a)))");
		Decimal value = expr.Bind("a", Math.PI/6).Eval<Decimal>(); 
		Console.WriteLine(value); //return 0		
	}
}

5.7 Deal with string

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		Expression taxExpr = new Expression("IF(LOWER(TAX_CODE)='vat',amount*10/100,IF(LOWER(TAX_CODE)='gst',amount*15/100,0))");
		taxExpr.Bind("TAX_CODE","GST");
		taxExpr.Bind("amount", 5005m);
		Decimal value = taxExpr.Eval<Decimal>();
		Console.WriteLine(value);
	}
}

5.8 Concatenate strings

using System;
using org.matheval;
					
public class Program
{
	public static void Main()
	{
		Expression expr = new Expression("CONCAT('The United States of ', 'America')");
		String value = expr.Eval<String>();	
		Console.WriteLine(value);//The United States of America	
	}
}

6.License

MIT license