Byces.Calculator 3.3.0

Byces.Calculator

A simple .NET calculator that solves expressions

1. Usage example
2. Building expressions
3. Available operators
4. Available functions
5. Available variables
6. Building your own functions and variables
7. Benchmark
8. Future goals
9. Feedback and bugs

Usage example

ICalculator calculator = new CalculatorBuilder().Build();

string expression = "2 + 5 * 3";
var mathResult = calculator.GetDoubleResult(expression);

if (mathResult.IsValid) // true
{
    Console.WriteLine(mathResult.Result); // 17
}
else
{
    Console.WriteLine(mathResult.ErrorMessage);
}

Building expressions

Before showing some syntax examples, here are some observations:

• Numbers, variables, operators and functions are not case-sensitive
• The calculator is not sensitive to whitespace by default and using it has a low impact on performance

// You can use signs to represent negative and positive numbers
string expressionExample1 = "-5 + +5";

// You can use parentheses to set priorities in the expression
string expressionExample2 = "((2 + 5) * 2) * 3";

// You can also represent numbers like this
string expressionExample3 = "1E+3";

// This is an expression with two operators and two functions
string expressionExample4 = "fact(2 + 3) * fact3";

// You can also use implicit multiplication
string expressionExample5 = "2(5)";

Available operators

Arithmetic

Logical and Comparison

Special

Available functions

Arithmetic

Logic and Comparison

Trigonometry

Others

Available variables

Number

Boolean

Building your own functions and variables

Currently, the classes you can inherit are: FunctionItem, NumberItem and BooleanItem

Remember that you need to provide the assembly where the custom functions and variables are located

The library currently supports ServiceProvider to construct functions and variables, you can use transient and singleton services.

Obs: It is worth remembering that the created instances (Variables, Functions and Operators) are created only once per calculator.

Example

internal sealed class CustomVariable : NumberItem
{
    // You can add multiple strings
    public CustomVariable(): base("MYCUSTOMVARIABLE")
    {
    }
    
    /*
    * If a variable is constant or a function is pure. You can set this 
    * property to true, this will optimize a calculator that uses the 
    * option to cache expressions
    */
    public override bool Pure => true; // Default is false
    
    public override double GetValue()
    {
        return 10;
    }
}

internal sealed class CustomFunction : FunctionItem
{
    public CustomFunction(): base("?")
    {
    }
    
    public override int ParametersMin => 1; // Default is 1
    
    public override int ParametersMax => 1; // Default is -1 (No limits)
    
    public override bool Pure => true;
    
    public override Variable Operate(ReadOnlySpan<Variable> variables)
    {
        return 2 * variables[0].Double; // The struct Variable already does the implicit conversion
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(CustomVariable);
        ICalculator calculator = new CalculatorBuilder()
            .WithAssemblies(type.Assembly)
            .Build();

        string expression = "?MyCustomVariable + 10";
        var mathResult = calculator.GetDoubleResult(expression);

        Console.WriteLine(mathResult.Result); // 30
    }
}

Benchmark (100,000 iterations)

In the Benchmark below, 100,000 iterations were made for each method

BenchmarkDotNet v0.13.12, Arch Linux
AMD Ryzen 5 3500X, 1 CPU, 6 logical and 6 physical cores
.NET SDK 8.0.102
  [Host]     : .NET 8.0.2 (8.0.224.6711), X64 RyuJIT AVX2
  DefaultJob : .NET 8.0.2 (8.0.224.6711), X64 RyuJIT AVX2

Expressions

Future goals

• Add more functions, variables and operators
• Try to increase performance

Feedback and Bugs

If you find any bugs or have any suggestions, feel free to send them!