PSC.Evaluator 1.0.0

PureSourceCode Evaluator

PSC.Evaluator is a mathematical expressions evaluator library written in C#. Allows to evaluate mathematical, boolean, string and datetime expressions.

Code is written in pure C# based on .NET Standard, run on the fly. We don't use any third party libraries or packages.

Installation

Using Package Manager

PM> Install-Package PSC.Evaluator

Usage examples

Basic evaluator

using System;
using PSC.Evaluator;

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

Conditional statements

using System;
using PSC.Evaluator;

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
	}
}

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);
  }
}	

Min, max, sum, avg

using System;
using PSC.Evaluator;

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)
	}
}

Round, floor, ceiling

using System;
using PSC.Evaluator;

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
	}
}

Trigonometry

using System;
using PSC.Evaluator;

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
	}
}

Deal with string

using System;
using PSC.Evaluator;

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);
	}
}

Concatenate strings

using System;
using PSC.Evaluator;

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
	}
}

Documentation

1. Object initialization

Expression expression = new Expression("(a + b) / 2 ");

or using default constructor + SetFomular() method:

Expression expression = new Expression();
expression.SetFomular("(a + b) / 2 ");

2. Bind variable

Expression expression = new Expression("(a + b) / 2 ");
expression.Bind("a", 3).Bind("b",5);

3. Eval expression c#

Expression expression = new Expression("(a + b) / 2 ");
expression.Bind("a", 3);
expression.Bind("b",5);
Object value = expression.Eval(); // will return 4

4. Multiple methods just in one line (method chaining)

Object value = new Expression("(a + b) / 2 ").Bind("a", 3).Bind("b", 5).Eval();

5. Using conditional statements

IF/ELSE condition

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>(); // will return 92.5

SWITCH/CASE condition

Expression expr = new Expression("SWITCH(name,1,'apple',2,'mango',3,'banana','N/A')");
// bind variable
expr.Bind("name", 2);
// eval
String value = expr.Eval<String>(); // return "mango"

6. Validate expression before evaluate

Expression expression = new Expression("SUM(1,2,3) + true");

// validate expression
List<String> errors = expression.GetError(); 
if(errors.Count == 0)
{
	// No error
}

7. Get variables that appear in the expression

Expression expression = new Expression("sin(pi/2+x)-cos(x) = a");
// validate expression
List<String> errors = expression.GetError();
if (errors.Count == 0)
{
	// get variables
	List<String> variables = expression.getVariables();
	foreach (String variable in variables)
	{
		Console.WriteLine(variable); // will print x, a
	}
}

8. Disable functions

Expression expression = new Expression();
expression.DisableFunction("SIN");
expression.DisableFunction("COS");

or

Expression expression = new Expression();
expression.DisableFunction(new string[] { "SIN", "COS" });

9. Work with number expression

Example 1: Scale and rounding mode

Use setScale() method to set number of digits to the right of the decimal point. Use setRoundingMode() method to set rounding mode. You can choose 1 of the following options:

• MidpointRounding.AwayFromZero
• MidpointRounding.ToEven
• MidpointRounding.ToZero

Expression expression = new Expression("pi/2");
expression.SetScale(3);
expression.SetRoundingMode(MidpointRounding.ToEven);
Decimal value = expression.Eval<Decimal>(); // return 1.571

Example 2: Simple expression

Expression expr = new Expression('(a+b+c)/2');
expr.Bind("a",2);
expr.Bind("b",3);
expr.Bind("c",16);
Object value = expr.Eval(); // return 10.5

Example 3: Complex expression

Expression expr = new Expression("tan(a)^3-((3*sin(a)-sin(3*a))/(3*cos(a)+cos(3*a)))");
expr.Bind("a", System.Math.PI / 4);
Object value = expr.Eval(); // return 0

Example 4: Min, max

Expression expr = new Expression("MIN(a,b,c)");
expr.Bind("a", 2);
expr.Bind("b", 3);
expr.Bind("c", 16);
int value = expr.Eval<int>(); // return 2

Example 5: Min, max with collection variable

Expression expr = new Expression("MAX(a)");
expr.Bind("a", new List<Decimal> { 10m, 9.6m, 135, 724.2m, 6m, -4m });
Decimal value = expr.Eval<Decimal>(); // return 724.2

Example 6: Sum, average

Expression expr = new Expression("SUM(a,b,c)");
expr.Bind("a", 2d);
expr.Bind("b", 3d);
expr.Bind("c", 16d);
Double sum = expr.Eval<Double>(); // return 21
expr.SetFomular("AVERAGE(a,b,c)");
Double avg = expr.Eval<Double>(); // return 7

Example 7: Sum, average using collection variable

Expression expr = new Expression("SUM(a)");
expr.Bind("a", new List<Decimal> { 2m, 3m, 16m });
Decimal sum = expr.Eval<Decimal>(); // return 21
expr.SetFomular("AVERAGE(a)");
Decimal avg = expr.Eval<Decimal>(); // return 7

Example 8: Round, Floor, Ceiling

Expression expr = new Expression("ROUND(2.149, 1)");
Object value = expr.Eval(); // return 2.1

Expression expr = new Expression("FLOOR(2.149)");
Object value = expr.Eval(); // return 2

// Rounds 3.7 down to nearest multiple of 2
Expression expr = new Expression("FLOOR(3.7,2)");
Object value = expr.Eval(); // return 2

Expression expr = new Expression("CEILING(2.149)");
Object value = expr.Eval(); // return 3

// Rounds 1.5 up to the nearest multiple of 0.1
Expression expr = new Expression("CEILING(1.5, 0.1)");
Object value = expr.Eval(); // return 1.5

Example 9: Trigonometry calculation

Expression expr = new Expression('SIN(PI())^2+COS(PI())^2');
Object value = expr.Eval(); // return 1

Expression expr = new Expression("sin(a) - cos(a) = SQRT(2) * sin(a - pi / 4)");
bool value = expr.Bind("a", Math.PI/5).Eval<bool>(); // return true

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>(); // return 0

Example 10: Unary operator

Expression expr = new Expression("3--2+--3-(-(++2))");
Object value = expr.Eval(); // return 10

10. Work with string

Example 1: Left, right

Expression expr = new Expression("IF(VALUE(LEFT(date,4))<2020,'n/a','generation of ' & LEFT(date,4))");
expr.Bind("date", "2022-01-20");
String value = expr.Eval<String>();

Example 2: Calculate tax

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>();

Example 3: Concatenate strings

Expression expr = new Expression("CONCAT('The United States of ', 'America')");
String value = expr.Eval<String>(); // The United States of America

11. Work with datetime

December 30, 1899 date system

We use 1899 date system, the first day that is supported is December 30, 1899. Any date you supply to this library will be converted into a serial number that represents the number of elapsed days starting from December 30, 1899. Look at the sample below:

Expression expr = new Expression("DATETIME(2025,01,02,12,11,10)");
Decimal serialDate = expr.Eval<Decimal>(); // return 45659.507755 (days elapsed from December 30, 1899)
DateTime datetime = expr.Eval<DateTime>(); // return 2025/01/02 12:11:10

Setting holidays and weekend for expression context

Expression expr = new Expression("NETWORKDAYS(B5,C5)");
expr.SetHolidays(
        new DateTime[] {
            new DateTime(2017,11,23),
            new DateTime(2017, 12, 25),
            new DateTime(2018, 1, 1)
        }
    );
expr.SetWeekends(new Int32[] { 1, 2, 3 }); // Sunday = 0, ..., Saturday = 6
expr.Bind("B5", new DateTime(2017, 1, 15));
expr.Bind("C5", new DateTime(2018, 1, 21));
Decimal value = expr.Eval<Decimal>(); // return 212

Example 1: Calculate networkday

Expression expr = new Expression("NETWORKDAYS(DATEVALUE('2021-03-30'),DATEVALUE('2022-05-16'))");
int value = expr.Eval<int>(); // return 295

Expression expr = new Expression("NETWORKDAYS(startdate,enddate)");
expr.Bind("startdate", new DateTime(2021, 08, 11));
expr.Bind("enddate", new DateTime(2021, 10, 4));
Object value = expr.Eval(); // return 39

Example 2: Calculates the number of days, months, or years between two dates.

Expression expr = new Expression("DATEDIFF(DATEVALUE('2021-01-31'),DATEVALUE('2029-08-29'),'Y')");
Object value = expr.Eval(); // return 8

Expression expr = new Expression("DATEDIFF(DATEVALUE('2021-01-31'),DATEVALUE('2029-08-29'),'M')");
Object value = expr.Eval(); // return 102

Expression expr = new Expression("DATEDIFF(DATEVALUE('2021-01-31'),DATEVALUE('2029-08-29'),'D')");
Object value = expr.Eval(); // return 3132

Expression expr = new Expression("DATEDIFF(DATEVALUE('2021-01-31'),DATEVALUE('2029-08-29'),'MD')");
Object value = expr.Eval(); // return 29

Example 3: Calculates the number of days, hours, mins between two datetime.

Expression expr = new Expression("DATETIME(2021,2,28,15,50,0)-DATETIME(2021,2,21,23,0,0)");
Decimal value = expr.Eval<Decimal>(); // return 6.70139 (days)

Expression expr = new Expression("(DATETIME(2021,2,28,15,50,0)-DATETIME(2021,2,21,23,0,0))*24");
Decimal value = expr.Eval<Decimal>(); // return 160.8 (hours)

Expression expr = new Expression("(DATETIME(2021,2,28,15,50,0)-DATETIME(2021,2,21,23,0,0))*24*60");
Decimal value = expr.Eval<Decimal>(); // return 9650 (mins)

Example 4: Calculates the number of days, hours, mins between two timespan.

Expression expr = new Expression("(endtime-TIME(17,0,0))*24*60");
expr.Bind("endtime", new TimeSpan(18, 20, 0));
Decimal value = expr.Eval<Decimal>(); // return 80 (mins)

Example5: Substract, add datetime

Expression expr = new Expression("DATETIME(2021,2,28,15,50,0)-DATETIME(2021,2,21,23,0,0)");
Object value = expr.Eval(); // return 6.701389 (days)

Expression expr = new Expression("DATE(2021,2,28)-DATE(2021,2,21)");
Object value = expr.Eval(); // return 7 (days)

Expression expr = new Expression("DATE(2021,9,20)+3");
DateTime value = expr.Eval<DateTime>(); // return 2021-09-23

Expression expr = new Expression("TIME(10,10,0)+TIME(10,10,0)");
TimeSpan value = expr.Eval<TimeSpan>(); // return 20:20:00

12. Supported operators, constants and functions in this expression evaluator library

Supported Operators

Supported conditional statements

Supported logical and math functions

Supported Constants

Supported text functions

Supported date&time functions