AngouriMath
AngouriMath is an open-source library that enables to work with non-linear multi-variable expressions. Its functionality includes derivation, variable substitution, equation solving, equation system solving, definite integration, formula-to-latex formatting, working with mathematical sets, and some more.
If you are new to AM, we suggest you checking out some samples instead of reading boring documentation. If you prefer full manual to AM, see Wiki. If you want to contribute, we surely appreciate it, but so far do not have documentation for you. It will appear soon!
Examples
Build an expression
var x = MathS.Var("x");
var y = MathS.Var("y");
var c = x * y + x / y;
Console.WriteLine(MathS.Sqr(c));
>>> (x * y + x / y) ^ 2
Use as a simple calculator
var inp = "1 + 2 * log(3, 9)";
var expr = MathS.FromString(inp);
Console.WriteLine(expr.Eval());
>>> 5
Substitute variables
var x = MathS.Var("x");
var expr = x * 2 + MathS.Sin(x) / MathS.Sin(MathS.Pow(2, x));
var subs = expr.Substitute(x, 0.3);
Console.WriteLine(subs.Eval());
>>> 0,9134260185941638995386706112
Find derivatives
var x = MathS.Var("x");
var func = MathS.Sqr(x) + MathS.Ln(MathS.Cos(x) + 3) + 4 * x;
var derivative = func.Derive(x);
Console.WriteLine(derivative.Simplify());
>>> 4 + (-1) * sin(x) / (cos(x) + 3) + 2 * x
Build expressions faster
Entity expr = "sqr(x + y)";
Console.WriteLine(expr.Expand().Simplify());
>>> x ^ 2 + 2 * x * y + y ^ 2
Simplify
var x = MathS.Var("x");
var a = MathS.Var("a");
var b = MathS.Var("b");
var expr = MathS.Sqrt(x) / x + a * b + b * a + (b - x) * (x + b) +
MathS.Arcsin(x + a) + MathS.Arccos(a + x);
Console.WriteLine(expr.Simplify());
>>> 2 * a * b + b ^ 2 + pi / 2 + x ^ (-1 / 2) - x ^ 2
Render latex
var x = MathS.Var("x");
var y = MathS.Var("y");
var expr = x.Pow(y) + MathS.Sqrt(x + y / 4) * (6 / x);
Console.WriteLine(expr.Latexise());
>>> {x}^{y}+\sqrt{x+\frac{y}{4}}\times \frac{6}{x}
Play with complex numbers
var expr = MathS.Pow(MathS.e, MathS.pi * MathS.i);
Console.WriteLine(expr);
Console.WriteLine(expr.Eval());
>>> e ^ (pi * i)
>>> -1
Solve equations analytically
Under developing now and forever (always available)
Entity expr = "(sin(x)2 - sin(x) + a)(b - x)((-3) * x + 2 + 3 * x ^ 2 + (x + (-3)) * x ^ 3)";
foreach (var root in expr.Solve("x"))
Console.WriteLine(root);
>>> arcsin((1 - sqrt(1 + (-4) * a)) / 2) - (-2) * n * pi
>>> 2 * n * pi + pi - arcsin((1 - sqrt(1 + (-4) * a)) / 2)
>>> arcsin(0.5 * (1 + sqrt(1 + (-4) * a))) - (-2) * n * pi
>>> 2 * n * pi + pi - arcsin((1 + sqrt(1 + (-4) * a)) / 2)
>>> b
>>> -i
>>> i
>>> 1
>>> 2
Solve systems of non-linear equations
Under developing now and forever (always available)
var system = MathS.Equations(
"cos(x2 + 1)^2 + 3y",
"y * (-1) + 4cos(x2 + 1)"
);
Console.WriteLine(system.Latexise());
var solutions = system.Solve("x", "y");
Console.WriteLine(Solutions.PrintOut());
Integrate
Only definite integral over single variable is supported yet :(
var x = MathS.Var("x");
var expr = MathS.Sin(x) + MathS.Sqrt(x) / (MathS.Sqrt(x) + MathS.Cos(x)) + MathS.Pow(x, 3);
Console.WriteLine(expr.DefiniteIntegral(x, -3, 3));
var expr2 = MathS.Sin(x);
Console.WriteLine(expr2.DefiniteIntegral(x, 0, MathS.DecimalConst.pi));
>>> 5.56669223384056 + 0.0889406793629381i
>>> 1.98003515236381
Compile functions
Compiled functions work 15x+ faster
var x = MathS.Var("x");
var expr = MathS.Sin(x) + MathS.Sqrt(x) / (MathS.Sqrt(x) + MathS.Cos(x)) + MathS.Pow(x, 3);
var func = expr.Compile(x);
Console.WriteLine(func.Substitute(3));
Try new syntax
Entity expr = "3x3 + 2 2 2 - x(3 0.5)";
Console.WriteLine(expr);
>>> 3 * x ^ 3 + 2 ^ 2 ^ 2 - x * sqrt(3)
Work with sets
var A = new Set(3, 4, (5, 6)); // {3, 4} | [5; 6]
var B = new Set((x, MathS.Sqrt(x)), 4);
var C = (A | B) & A;
Try SymPy syntax
var x = SySyn.Symbol("x");
var expr = SySyn.Exp(x) + x;
Console.WriteLine(SySyn.Diff(expr));
Console.WriteLine(SySyn.Diff(expr, x));
Console.WriteLine(SySyn.Diff(expr, x, x));
Work with numbers
var rat1 = Number.CreateRational(3, 4);
var rat2 = Number.CreateRational(5, 6);
Console.WriteLine((rat1 + rat2).ToString());
>>> 19 / 12
Translate number systems
string x = MathS.ToBaseN(-32.25, 4);
Console.WriteLine("-32.25(10) = " + x + "(4)");
double y = MathS.FromBaseN("AB.3", 16);
Console.WriteLine("AB.3(16) = " + y + "(1)");
>>> -32.25(10) = -200.1(4)
>>> AB.3(16) = 171,1875(1)
Performance
Performane improved a lot. Testing on i7-7700HQ and expr = MathS.Sin(x)
we get the following report:
Function | Time per iteration |
---|---|
Substitute(x, 3).Eval() from 1.0.13 | 12000 ns |
Substitute(x, 3).Eval() from 1.0.15 | 2500 ns |
Call(3) from 1.0.15 | 54 ns |
Complex.Sin(3) | 27 ns |
If we take expr = MathS.Sin(MathS.Sqr(x)) + MathS.Cos(MathS.Sqr(x)) + MathS.Sqr(x) + MathS.Sin(MathS.Sqr(x))
, AM Compiled
is faster than any other methods:
Method | Time per iteration |
---|---|
AM Compiled | 310.0 ns |
In-code expression | 424.2 ns |
LinqCompiled | 435.9 ns |
Substitute(x, 3).Eval() | 6777.3 ns |
It is true since release of 1.0.17.1 Beta, when cache instructions in compiled functions were added.
Finally, if we take expr = (MathS.Log(x, 3) + MathS.Sqr(x)) * MathS.Sin(x + MathS.Cosec(x))
,
we get the following performance
Method | Time per iteration |
---|---|
AM Compiled | 380.8 ns |
In-code expression | 211.5 ns |
Substitute(x, 3).Eval() | 5656.3 ns |
So, for most cases compilation will save you enough time even though built-in functions are still faster sometimes.
More information
More info about methods see on Wiki.