A correctness release. Almost everything below is a wrong answer becoming a right one, and most of it was found by harnesses rather than reported — boundary points where a rule's assumption fails, one child process per case so a stack overflow is a result rather than the end of the run, every documented code sample compiled and run, and the generated SymPy code executed rather than read. Every input whose result is now different is listed, with both values and why, in BREAKING-CHANGES.md under 2.1.0 — since 2.0.0 — read that before upgrading. Assembly version stays 2.0.0.0, so this is a drop-in replacement for 2.0.0.

Answers that changed because they were wrong:

• arcsin(sin(x)) and three siblings no longer cancel off the principal branch: arcsin(sin(3)) was 3 and is pi - 3. Four rules had been wrong since 2020.
• arctan(x) + arccotan(x) is not always pi/2 — this library's arccotan has range (-pi/2, pi/2], so the sum is -pi/2 for negative x.
• ln(e^x) is no longer x, which is wrong wherever Im x leaves (-pi, pi]: at x = 3*pi*i the expression is pi*i.
• log(1, 1) was 0 and is NaN — it is 0/0; log(1, 2) was +oo.
• abs(sgn(x)) and sgn(abs(x)) were 1, and both are 0 at x = 0.
• A logical connective is no longer strict in NaN: False and u is False for an operand with no truth value, which is what Simplify already answered while evaluation said NaN.
• A connective over a number now declines instead of reporting the same type error three different ways. A number is not a truth value.
• A conditional set's bound variable was named from a hash of its predicate, which could spell true and throw — an intermittent CI failure that would not reproduce.

• abs folds where the sign of its argument is known: abs(-sqrt(6)) is sqrt(6), so a concrete quadratic inequality no longer answers with abs(-sqrt(6)) / 2 as an endpoint.
• -(a - b) is turned round wherever it sits — inside a power, a function's argument or a matrix, not only at the root — and Expand descends into a matrix. A solved system's entries are shorter for it.
• NaN is a literal. It printed as NaN and parsed back as a variable of that name, so NaN - NaN was 0.
• MathS.ToSympyCode emits Python that runs and stays exact. Any non-integer rational produced a SyntaxError, NaN and the infinities were unbound names, and 1/2 arrived in SymPy as the float 0.5.

• lim x->+oo (x^2)^x / e^(2*x*ln(x)) and lim x->+oo x^x / e^(x*ln(x) - ln(x)) are unevaluated where they used to be answered. They need ln(a^c) = c*ln(a), which is false in general; on the way to +oo the base really is positive, and there is currently no way to tell the simplifier so. Unevaluated rather than NaN, so a caller is told nothing was settled rather than told the limit does not exist.
• false and 0 and true or 0 were False and True by short-circuit. Whether an operand is admissible cannot depend on whether the operator happened to need it.

• NaN is a keyword, so it can no longer be a variable name — the same trade mod took in 2.0. Only the exact spelling: NaNx and NaN_1 are still variables.

• Measured rather than hoped for: 2.0.0 and 2.1.0 benchmarked minutes apart on one machine and published as a pair. No regression — the largest real move is SolveMedium at +4.6%, the rest inside ±3%, and allocation is flat with three rows byte-identical.

A major version, so it takes the breaking decisions 1.x could not. Mathematical correctness comes ahead of backward compatibility here: several of the changes below are a wrong answer becoming a right one, which still breaks code that depended on the wrong one. Every input whose result is now different is listed, with both values and why, in BREAKING-CHANGES.md — read that before upgrading.

Renames and removals:

• Latexise is Latexize, ILatexiseable is ILatexizeable. British spelling is gone from the API.
• MathS.Quantum.Factorise is TensorFactorize, one letter away from the unrelated Entity.Factorize before; IsNormalised is IsNormalized.
• The 28 members that carried [Obsolete] through 1.x are removed. Each obsolete message named its replacement.
• The implicit conversions from Entity[], List<Entity> and (Entity, Entity) to Entity are removed. The list one made every params Entity[] overload in the library uncallable with a list.
• Minusf's fields are named for the right operands at last: it was Subtrahend - Minuend.
• Target frameworks are netstandard2.0, net8.0 and net10.0; net7.0 is gone.

• sqrt(x^2) and sqrt(-x) are left as written rather than becoming x and i*sqrt(x), which were wrong for negative x.
• Numbers below 1e-16 are kept instead of being rounded to 0.
• -7 % 3 is 2: mod takes the sign of the divisor, as mathematicians, SymPy, Mathematica and Maxima all have it.
• abs(x) = -1 is the empty set, not a set of numbers that do not satisfy it.
• An identity equation solves to all of CC; a numeric root set has one root per root rather than one per starting point.
• A quadratic inequality with a symbolic coefficient is right for either sign of it.
• Many limits that answered NaN — "this does not exist" — now give the value, or say honestly that they could not settle it.
• What Stringize prints parses back into the expression it printed. It did not for powers, lambdas, applications, piecewises, or complex numbers with a fractional imaginary part.

• floor, ceil, round, min, max and gcd are functions rather than parse errors. round is half to even.
• A transformation layer: Simplify, Expand, Factorize, Differentiate, Integrate and Limit are adapters over a Transformation that carries what it claims about its output and how well justified the claim is. Rewrites can be recorded.
• Boolean minimisation, quantum states with tensor factorisation, and a much stronger limit and integration pipeline.
• A syntax reference and an exception reference in the repository.
• Assembly version is pinned at 2.0.0.0 for the whole of 2.x, so every 2.x release is a drop-in replacement for a signed-assembly consumer.

• The MyGet per-push feed. Releases publish to NuGet; remove the feed from your NuGet.Config if you had it.

Kernel functional and C#:

• Simplification a bit improved for sets
• η-reduction added for lambda calculs entities (simplification now triggers beta+eta reduction)
• Bug related to simplification of tangent fixed (it turned NaN when should be 0)
• A few xor simplification patterns thanks DavidBeh
• Now installing only AngouriMath (without interactive) still loads LaTeX in notebooks, thanks new dib kernel extension feature
• Matrix concatenation API

• Polar plot added, thanks cyberillithid
• Sliders for plotting added (2D and 3D)
• Spherical plotting

Kernel functional and C#:

• Imprecise equality from 1.4-preview.2 implemented.
• Added compilation of Piecewise node, thanks @Illuminati-CRAZ.
• Division, logarithm, power, and trigonometric functions experienced a behavioural change: now, they upcast integer types to floating point.

• A few more default variables added to the terminal by default, thanks dogayalcin.
• PeterO.Numbers assembly gets loaded into the terminal too.

Kernel functional and C#:

• Application. It is a node, which represents one expression applied to another one. No parser support yet.
• Built-in functions will now be simplified from application of an expression applied to a known variable, for example, x applied to sin is sin of x. No parser support yet.
• Lambda. This node represents an abstraction working similarly to that in lambda calculus. It has one parameter, and when an expression is applied, this parameter is substituted with this expression. No parser support yet.
• Imprecise equality API added but not implemented.
• Bugs fixed. NaN is now returned when comparing NaN and a number with inequality signs.

• Now there is a package AngouriMath.Experimental.
• Entity, Complex, Real, Rational and Integer implement generic math from .NET 6.

• Fixed bug when crashed on too small sizes.
• Reduced the API calls to OS-unsupported API.
• The terminal is now available as a .NET global tool, see NuGet.

F# and interactive:

• Added plotting in AngouriMath.Interactive namespace: Plot.linear, Plot.scatter for 2D (functions over one variable), and Plot.surface, Plot.scatter3D for 3D (functions over two variables). See visualization.
• Formatters for PeterO Numbers added.

• Terminal repo merged into AngouriMath
• Complete redesign by using Spectre.Console and Radline. See more.

Kernel functional and C#:

• No more Tensor, we only work with Matrix now.
• A few synonyms added for hyperbolic functions.
• Greek and cyrillic latters are now parsable. Symbols \n and \s are now ignored by the parser.
• Limits improved.
• 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.
• Rank of a matrix, Reduced row echelon form added.
• 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.
• 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.
• Taylor expansion of functions of several variables added: MultivariableTaylorExpansionTerms (infinite generator of terms), MultivariableTaylorExpansion (returns an expression).
• Added a lot of number-theory related methds, mostly in the UnsafeAndInternal and ExperimentalFeatures categories. Added methods: SymbolicFormOfSine, SymbolicFormOfCosine, ExpandSineOfSum, ExpandConsineOfSum, ExpandSineArgumentMultiplied, ExpandCosineArgumentMultiplied, GetSineOfHalvedAngle, GetCosineOfHalvedAngle, DecomposeRational, GetSineOfHalvedAngle
• SymbolicFormOfSine and SymbolicFormOfCosine exposed in MathS.Compute. Use them to find the exact form of sines beyond basic table values like pi/3, pi/6, etc. These algorithms can decompose sin(17/42 pi) into the exact analytical form with roots and arithmetical operations only. They return null if cannot expand a sine or cosine into an exact form.
• Explicit parsing is now allowed with MathS.ExplicitParsingOnly, so that omitted operators are not inserted automatically.
• MathS.Parse returns an Either of a successfully parsed entity or a failure of a few possible reasons of parsing failure. Close to some advanced Result type.
• Bugs related to
  • imprecise computing of corner cases of tangent
  • allocations on accessing a property
  • integral of a piecewise
  are fixed.

• 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.
• 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.
• Overload for ***. added as a tensor multiplication.
• Overload for ****. added as a tensor power.
• 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.
• 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.
• 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.
• All node-creating functions now apply InnerSimplified automatically, unless explicitly specified otherwise.
• Functions to compile expressions added.

• Parsing, to string, latex, basic calculus, solvers, properties are exposed.
• 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.

• Honk# is shipped with AngouriMath instead of FieldCache and a few other packages. Not only some internal functions of AM are rewritten in it, but AM adopts fluent style of using it natively, for example, by having API exposing Either (anonymous type union).
• AngouriMath now multitargets netstandard2.1 (which does not require System.Memory dependency) and .NET Framework 4.7.2 (which also loads such dependencies as System.Numerics), so now it should be more convenient to use from legacy apps.

• 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.

• 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.

• 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.

• 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.

• 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.

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)

Domains

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

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

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

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

Interactive

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

Multithreading

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