What's new

1.3 (under development) The release date: TBD.

Breaking changes

Kernel: no more Tensor, we only work with Matrix now.

F# and Jupyter: some operators were removed, all functions were renamed to camelCase and declaratively.

... to be continued

1.3-preview.5 (under development)
F# and Interactive:
  • Now there are also operators less, greater, less or equal, greater or equal which create entities.
  • Functions det, inverse, adjugate added for matices.
  • Conjugate of a complex is now a property.

Kernel functional and C#:
  • Implicit operators improved (one for BigInteger added).
  • An important bug related to determinant fixed (determinant, which works via Gaussian elimination, did not take into account the number of swaps performed by the algorithm).
  • Inverse and Adjugate are now properties. They do not throw exceptions. Instead, if they cannot be evaluated, a null is returned.
  • No matrix division allowed anymore.
F# and Interactive:
  • There are now matrix operators, which unconditionally return a matrix. Here is the list of them: |+, |-, |*, |/, |**. Module: AngouriMath.FSharp.MatrixOperators.
  • There is also function asMatrix.
C++ (experimental):
  • Visit the lab to see samples.
  • See the instructions how to get it, if you want to participate in the project or experiment with that.

Kernel functional and C#:
  • Max term count increased by a lot. No power limit in the expansion algorithm.
  • Parentheses fixed in LaTeX for negative number cases (and negation sign).
  • A couple of bugs related to matrices fixed. ReducedRowEchelonForm and Rank added, GaussianEliminated replaced with RowEchelonForm (here we stick to the definition which implies that leading elements can differ from ones).
  • Piecewise now works correctly for cases when a node is applied to a whole piecewise.
F# and Interactive:
  • All modules are moved to the AngouriMath.FSharp namespace. For Interactive, there is now namespace Interactive. There is also no need to call magic commands to bind latex to rendering.
  • Overload for ** added as a power operator.
  • Interactive.AggressiveOperators module allows for arithmetic operators overloaded for a pair of object and object. The reason is to avoid using additional methods to parse an expression while performing some computations.


Kernel functional and C#:

  • Upcasts added to compilation, as well as many overloads and extension methods.
  • Latexise does not produce "\times" anymore (nothing or \cdot instead). It also now produces correct code in case when a variable has an index (both variable and index are latexised properly).
  • Tensors completely reconsidered. No more vectors or tensors. There are only matrices. Moreover, operators now, instead of being elementwise, are now matrix-meaningful. A vector is considered a one-column matrix. A lot of methods of matrices are now exposed.
  • C++ wrapper (under development): parsing, to string, latex, basic calculus, solvers, properties are exposed.
  • F# wrapper significantly improved. Matrices, settings, intervals were added. Naming was reconsidered in favor of declarative programming. It also now has the same versioning as the kernel package.


  • A few synonyms added for hyperbolic functions.
  • Greek and cyrillic latters are now parsable.
  • Limits improved.


1.2 brings us incredibly many features, completely reconsidering all patterns. Number of nodes was doubled, a lot of syntax related to solvers, building an expression tree, performance improved.

Not only that, we added AngouriMath.FSharp and AngouriMath.Interactive packages for working in F# and Jupyter respectively.

1.2 is not backward compatible with

We highly recommend reading this if you plan to migrate from to 1.2, as tons of concepts from were reconsidered and rewritten.

General structure

Now there's no operator's name. Moreover, there's no operator anymore. There are records for each separate logical action, be than a sum operator or sine function. They all are inside Entity's naming.

Active functions like renamed Differentiate, Integrate, and Limit now return an expression after InnerSimplified being applied. A lot of methods are now properties.

ToSymPy fixed, as well as many other bugs. Solvers and simplificators improved.

Math features

How the math of AM is improved.

Secant, Cosecant, Arcsecant, Arccosecant

Are now available as nodes with the obvious syntax and their synonyms.

Secant: sec(x)

Cosecant: cosec(x), csc(x)

Arcsecant: asec(x), arcsec(x)

Arccosecant: acsc(x), acosec(x), arccosec(x)

Hyberbolic trigonometric functions

All trigonometric functions (sin, cos, ..., arcsecant) now have their "-h" pair. For example, sinh, cosh, etc. They are not nodes, but they are parseable and available in AngouriMath.FSharp and AngouriMath.Interactive as well.

Abs and Signum and Phi nodes

Abs always returns a real non-negative number for a numerical argument. Signum always returns a complex number such that its absolute value is 1 for a numerical argument. One exception for signum is 0: for 0 it returns 0. Phi returns an integer (where Phi is the Euler's totient function).

Syntax for abs: abs(x), (|x|)

Syntax for signum: sgn(x), signum(x), sign(x)

Syntax for phi: phi(x)


Now every node is constrained within a domain. This init-get-only property is called Codomain. You can set this codomain for every node in a given expression. If a numerical value is outside of the codomain, Eval will return NaN, and Simplify would not take any additional actions, leaving node as it is.

Syntax: domain(x, ZZ), domain(x, QQ), ...

Note: since domain is not a node, it is true that domain(x, RR) = domain(domain(x, RR), RR)

Boolean algebra

Now there are many boolean operators added and they are nodes. Instead of Eval we now see EvalNumerical and EvalBoolean. Likewise, instead of Evaluable we see EvaluableNumerical and EvaluableBoolean.

Available operators and their syntaxes: not, or, xor, and, implies

Syntax of boolean constants: false, true

Equality and inequality nodes

Those return a Boolean when simplified. Inequality nodes result in NaN if evaluating on two numerical non-real values.

Syntax for equal, greater, less, greater or equal, less or equal: =, >, <, >=, <=

There's also compositional syntax separately for inequalities and inequalities, e. g. x < a < 4 <=> x < a and a < 4 and x = a = b <=> x = a and a = b. Although you cannot mix the two, that is, x < a = c is (x < a) = c (i. e. the fact whether x is less than a is equivalent to c)


Sets are now entities. There're FiniteSet (which you can iterate over), Interval (from one number to another one. Only reals are now supported), SpecialSet (something like domain. Its only parameter is of Domain type), ConditionalSet (for all values in its domain it is true if and only if the value satisfies the CSet's predicate).

Syntax for finite set: { 1, 2, 3 }

Syntax for interval: ('[' | '(') left ';' right (']' | ')'). So the square bracket means it's closed, the parenthesis means it's open. For example, [3; 5) means it is closed on the left end and open on the right one.

Syntax for SpecialSet: CC, RR, ZZ, QQ

Syntax for ConditionalSet: { x : predicate(x) } where predicate is a statement, e. g. { x | x > 0 and (y implies x = 0) }

The in statement allows to verify whether an element belongs to a set. E. g. 2 in { 2, 3 }

Limits improved

Added some patterns for non-defined expressions, for instance, the first and the second remarkable limits and a few more. L'Hopital's rule added as well.


Provided is a node, which turns into NaN if the predicate is false, turns into Expression if the predicate is true. For example, you may write 5 + (a provided b). As so, it remains unchanged, but if you subsisute true instead of b, you will get 5 + (a provided true) -> 5 + a. The whole expression will turn into NaN if any provided's predicate is false.

Exception: when a provided is in a finite set. Then, (a provided b) in A <=> (a in A) = b, that is, if a provided turns into undefined, it's excluded from the finite set.

Syntax: a provided b. It has the lowest priority, so a + b \/ c provided f and h = i is the same as (a + b \/ c) provided (f and h = i)


Piecewise-defined functions are finally added too. They allow you to define conditions under which different expressions will be substituted. For example, that is how we can define abs function for real x:

Entity abs = "piecewise(x provided x > 0, -x provided x <= 0)";
WriteLine(abs.Substitute("x", 3).EvalNumerical());
WriteLine(abs.Substitute("x", -3).EvalNumerical());

When a piecewise takes part in an expression, the expression will usually be expanded to piecewise, for example,

piecewise(a provided b, c provided d, ...) + 3
piecewise(a + 3 provided b, c + 3 provided d, ...)

IMPORTANT. The definition of AM's piecewise differs from the classical one. For the classical math one, piecewise turns into some case if this case's condition is true and all others are false. In AM's definition, piecewise turns into some case if this case's condition is true and all those *before* the considered case are false.

Syntax: piecewise(a provided b, c provided d, ...) if no otherwise case provided. piecewise(a provided b, c provided d, ..., e) for e as the otherwise case.

Industrial features

Features, related to industrial integration, production, researches. Usually, improved convenience or stability.

Ultimate exception class added

It is called AngouriMathBaseException, so that you can catch all exceptions thrown by AngouriMath by catching just one.

Performance improved

See Performance report

F# in AngouriMath

Now you can work with AngouriMath from F# without writing your own wrapper and work with AM's types directly. Check samples and readme to get more information


Now you can work in Jypyter with expressions being rendered directly to the output. See samples and readme for more information


Some methods like Solve and Simplify might take up to infinitely much time. Now, you can kill hung tasks.

New settings

Now, you don't have to pass a lambda. Instead, use syntax

using var _ = MaxExpansionTermCount.Set(10);
// do what is needed
Set generates a disposable struct, which, when disposed, rolls back the setting at the end of the scope. It is not recommended to dispose it your own, just let runtime do its job. The As, Global, and RollBackToDefault are marked as obsolete and not recommended to use anymore.

1.2-preview.6 Multithreading, casts for numbers added. AngouriMathBaseException is now root of all AM's exceptions. FieldCache moved to alpha.3, which is strongly named

1.2-preview.5 Hyberbolic functions are now parsable, Phi node added, a few vulnerabilities fixed

1.2-preview.4 A few security issues fixed, a few simple rules added, sorter refactored, ToSymPy fixed, Arcsecant & Arccosecant

1.2-preview.3 Derive -> Differentiate, now all calculus functions apply InnerSimplified automatically, naive set solver, bugs fixed

1.2-preview.2 A lot of patterns for sets added, bugs fixed, extensions for integrate, limit added

1.2-preview.1 Sets, domains, booleans, signum and abs Limits improved & some bugs fixed & nodes for limits, derivatives, integral Limits & gamma & factorial Bugs fixed + smart expansion + solver improved + EDecimal and EInteger instead of decimal and BigInteger

1.1.0 Added Numerix module, and this version is not compatible to all previous versions, migrate changes see in

1.0.20 Added Tensor, system of equations, polynom divisions, periodic roots for solvers, compilation boosted, simplification improved, LaTeX formatting improved, cache for compiled functions added, search boosted, tons of bugs fixed

2019-2021 Angouri · Project's repo · Site's repo · Octicons