{"id":400330,"date":"2024-06-29T15:12:01","date_gmt":"2024-06-29T15:12:01","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=400330"},"modified":"-0001-11-30T00:00:00","modified_gmt":"2024-06-29T15:12:01","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=400330","title":{"rendered":"What’s new in AngouriMath 1.2?<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n

Hi. The last 7 months I have been working on the greatest release of AngouriMath<\/a>. There is something I want to tell you.<\/p>\n

Briefly about the project<\/h3>\n

In November of 2019 I realized that it would be nice to have a symbolic algebra library for .NET, which could simplify expressions, solve equations, build latex code, and many more. That is how I decided to create one.<\/p>\n

\nBut this already exists…<\/summary>\n
\n

As long as I tell people about what I am working on, they suggest different solutions, be those to rewrite SymPy, make a wrapper over SageMath for .NET, pirate Wolfram|Alpha, use primitive mathnet.symbolics (about which they mention themselves).<\/p>\n

All of those have limitations or difficulties. In contrast, what I am working on is a very lightweight library, made and optimized for .NET specifically. It is open-source (under MIT).<\/p>\n<\/div>\n<\/details>\n

Release 1.2<\/h3>\n

In August one of the main contributors, @HappyPig375<\/a>, helped to rewrite a significant part of the library into a type hierarchy. Every operator\/function has its own node (type). Thanks to it, the library now has a more obvious API, improved performance and security. Now, let us go over what has been done within these 7 months.<\/p>\n

An expression is a record<\/h4>\n

For example, that is what Sumf <\/code>looks like<\/p>\n

public sealed partial record Sumf(Entity Augend, Entity Addend) : NumericNode<\/code><\/pre>\n
Thanks to it, now we can apply pattern matching:<\/p>\n
internal static Entity CommonRules(Entity x) => x switch {     \/\/ (a * f(x)) * g(x) = a * (f(x) * g(x))     Mulf(Mulf(Number const1, Function func1), Function func2) => func1 * func2 * const1,      \/\/ (a\/b) * (c\/d) = (a*c)\/(b*d)     Mulf(Divf(var any1, var any2), Divf(var any3, var any4)) => any1 * any3 \/ (any2 * any4),      \/\/ a \/ (b \/ c) = a * c \/ b     Divf(var any1, Divf(var any2, var any3)) => any1 * any3 \/ any2,<\/code><\/pre>\n
(it is a few examples of patterns used in the simplification algorithm)<\/p>\n
Math<\/h3>\n
Here I am going to over over features related to math itself.<\/p>\n
New functions<\/h4>\n
Secant<\/code>, cosecant<\/code>, arcsecant<\/code>, arccosecant <\/code>were added as separate nodes.<\/p>\n
12 hyperbolic functions were added. They do not have their own nodes and return their symbolic expression (sinh(x)<\/code>as(e.Pow(x) - e.Pow(-x)) \/ 2<\/code>).<\/p>\n
Abs <\/code>and Signum<\/code>. The syntax of Abs <\/code>is the following: (|x|)<\/code>. It looks similar to how we write in on a paper while at the same time allows to avoid ambiguouty (because | is symmetric, there might be problems with it).<\/p>\n
Euler’s totient function was added.<\/p>\n
WriteLine(@\"phi(8)\".EvalNumerical()); WriteLine(@\"(|-3 + 4i|)\".EvalNumerical()); WriteLine(@\"sinh(3)\".Simplify()); WriteLine(@\"sec(0.5)\".Simplify());<\/code><\/pre>\n
Prints<\/p>\n
4 5 (e ^ 3 - 1 \/ e ^ 3) \/ 2 sec(1\/2)<\/code><\/pre>\n
Domains<\/h4>\n
They allow to limit every node’s range. If a node is out of its domain, it turns into a NaN<\/code>, which makes the entire expression undefined. SpecialSet<\/code>s are used as values of domains.<\/p>\n
Booleans and logic<\/h4>\n
Logic operators were finally added. At the beginning, there was an idea to make those similar to what we use in programming; instead, it was decided to make them literal. That is why the syntax is: not<\/code>, or<\/code>, xor<\/code>, and<\/code>, implies<\/code>.<\/p>\n
To check whether an expression is evaluable into a Boolean<\/code>, you need to use EvaluableBoolean<\/code>. Same way, we use EvaluableNumerical <\/code>to check whether an expression is evaluable into a Number<\/code>.<\/p>\n
WriteLine(@\"(true or b) implies c\".Simplify());<\/code><\/pre>\n
(printsc<\/code>)<\/p>\n
Equality and inequality signs<\/h4>\n
They might carry the Boolean<\/code>type, if their operands are computed. Of course, the following were added: =<\/code>, <<\/code>, ><\/code>, <=<\/code>, >=<\/code>.<\/p>\n
You can also combine inequalities. For example, a > b > c<\/code> is interpreted asa > b and b > c<\/code>.<\/p>\n
WriteLine(@\"a < b >= c\".Simplify());<\/code><\/pre>\n
(Printsa < b and b >= c<\/code>)<\/p>\n
Sets<\/h4>\n
Sets were added. They are parsable and have their own nodes.<\/p>\n
The most naive type of set is FiniteSet<\/code>. Its syntax: { 1, 2, 3 }<\/code>.<\/p>\n
Intervals <\/code>also have familiar syntax: [1; 2]<\/code> for both points included, (1; 2)<\/code> for both excluded, [1; 2)<\/code> for the right one excluded, and (1; 2]<\/code> for the left one excluded. Complex intervals were removed because of their clumsiness.<\/p>\n
SpecialSet <\/code>are preset sets. Now we have CC<\/code>, RR<\/code>, QQ<\/code>, ZZ<\/code>, BB<\/code>\u00a0for complex, real, rational, integer and boolean values.<\/p>\n
ConditionalSet <\/code>is written in set-builder notation<\/a>, for example: { x : x > 0 and x^2 = y }<\/code> (any  x<\/code> such that greater than 0 and equalsy<\/code>).<\/p>\n
WriteLine(@\"({ 1, 2 } \\\/ { 5 }) \/\\ { x : x in [2; 3] and x > 0 } \".Simplify());<\/code><\/pre>\n
(Prints{ 2 }<\/code>)<\/p>\n
Limits improved<\/h4>\n
First remarkable, second remarkable limits transformation rules were added, as well as the l’Hopital’s rule.<\/p>\n
WriteLine(\"tan(a x) \/ (b x)\".Limit(\"x\", 0)); WriteLine(\"(sin(t) - t) \/ t3\".Limit(\"t\", 0));<\/code><\/pre>\n
(Printsa \/ b<\/code> and -1\/6<\/code> respectively)<\/p>\n
«Provided» node<\/h4>\n
Allows to set constraints on an expression. For example, square root on real numbers we can define as sqrt(x) provided x >= 0<\/code>. It will turn into NaN <\/code>if you substitute negative x<\/code>.<\/p>\n
If an expression being turned into NaN <\/code>is an element of a finite set, it will be excluded, instead of turning the whole expression into NaN<\/code>. It is the only exception for NaN<\/code>.<\/p>\n
Piecewise<\/h4>\n
Piecewise <\/code>is a sequence ofProvided<\/code>s. Unlike the classical piecewise-defined function, here the order of elements matters, and when computingPiecewise<\/code>, the firstProvided<\/code>\u00a0is returned such that its predicate is true.<\/p>\n
That is an example of how we can define the absolute value function for real numbers via Piecewise<\/code>:<\/p>\n
Entity abs = \"piecewise(x provided x > 0, -x provided x <= 0)\"; WriteLine(abs.Substitute(\"x\", 3).EvalNumerical()); WriteLine(abs.Substitute(\"x\", -3).EvalNumerical());<\/code><\/pre>\n
(Prints 3 in both cases)<\/p>\n
Ease and convenience of use<\/h2>\n
This part of the article about features making the use of AngouriMath more comfortable.<\/p>\n
Exceptions were reconsidered and refactored<\/h4>\n
Now all exceptions thrown by the library are somehow inherited from AngouriMathBaseException<\/code>. Because there is nop\/invoke<\/code> or IO, you can be assured that any exception assignable to AngouriMathBaseException\u00a0<\/code>does not bring any direct harm to the system or user’s data. In other words, when catching exceptions, now you can catch this exception in the last instance of Catch<\/code>.<\/p>\n
Performance improved<\/h4>\n
To be precise, the performance has been fluctuating throughout this all time. Nonetheless, it is still by far better than that of 1.1.0.5. Here <\/a>you can find a performance report by every key commit.<\/p>\n
F# is now supported<\/h4>\n
With this release, the API for AngouriMath is now supported natively for wonderful language F#. It might be not as functional as the main API, so in especially complicated cases, you still can call methods from the core library itself.<\/p>\n
Interactive<\/h4>\n
I wrote an article some time ago about AngouriMath in Jupyter<\/a>. AngouriMath.Interactive itself simplify converts ILatexiseable <\/code>into a LaTeX-code and renders it with MathJax (read more about it in the mentioned article).<\/p>\n
\"A
A simple example of using AngouriMath.Interactive in Jupyter<\/figcaption><\/figure>\n
Multithreading<\/h4>\n
All computations happen strictly in one thread. The library is not responsible for your threading problems. Moreover, all methods are thread-safe. The settings are local for every thread([ThreadStatic]<\/code>).<\/p>\n
The main feature of this update is that you can interrupt computations of Solve <\/code>orSimplify<\/code>. <\/p>\n
New settings<\/h4>\n
It is their third version. Even though I am not a big fan of the new solution, it is the best I could achieve. To set a new value of a setting, let us write<\/p>\n
using var _ = MaxExpansionTermCount.Set(10); \/\/ some code<\/code><\/pre>\n
Then this setting will be automatically rolled back to the previous value once the end of the scope is reached (the return type of Set<\/code>\u00a0isIDisposable<\/code>).<\/p>\n
That is about it<\/h3>\n
Thank you for your attention. I will be pleased to answer your questions.<\/p>\n
Anybody willing to contribute is welcome (contact me or fork and make your changes directly).<\/p>\n
References<\/h3>\n
    \n
  1. \n
    GitHub<\/a> page of the project.<\/p>\n<\/li>\n
  2. \n
    Website<\/a> of the project.<\/p>\n<\/li>\n
  3. \n
    Detailed What’s new<\/a>.<\/p>\n<\/li>\n
  4. \n
    Plans<\/a> for the future updates.<\/p>\n<\/li>\n
  5. \n
    My GitHub profile<\/a>.<\/p>\n<\/li>\n
  6. \n
    SymPy <\/a>— those who inspire me.<\/p>\n<\/li>\n<\/ol>\n<\/div>\n<\/div>\n<\/div>\n
    <\/div>\n

     \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438      https:\/\/habr.com\/ru\/articles\/545436\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
    <\/div>\n
    \n
    \n
    \n
    \n
    Hi. The last 7 months I have been working on the greatest release of AngouriMath<\/a>. There is something I want to tell you.<\/p>\n
    Briefly about the project<\/h3>\n
    In November of 2019 I realized that it would be nice to have a symbolic algebra library for .NET, which could simplify expressions, solve equations, build latex code, and many more. That is how I decided to create one.<\/p>\n
    \nBut this already exists…<\/summary>\n
    \n
    As long as I tell people about what I am working on, they suggest different solutions, be those to rewrite SymPy, make a wrapper over SageMath for .NET, pirate Wolfram|Alpha, use primitive mathnet.symbolics (about which they mention themselves).<\/p>\n
    All of those have limitations or difficulties. In contrast, what I am working on is a very lightweight library, made and optimized for .NET specifically. It is open-source (under MIT).<\/p>\n<\/div>\n<\/details>\n
    Release 1.2<\/h3>\n
    In August one of the main contributors, @HappyPig375<\/a>, helped to rewrite a significant part of the library into a type hierarchy. Every operator\/function has its own node (type). Thanks to it, the library now has a more obvious API, improved performance and security. Now, let us go over what has been done within these 7 months.<\/p>\n
    An expression is a record<\/h4>\n
    For example, that is what Sumf <\/code>looks like<\/p>\n
    public sealed partial record Sumf(Entity Augend, Entity Addend) : NumericNode<\/code><\/pre>\n
    Thanks to it, now we can apply pattern matching:<\/p>\n
    internal static Entity CommonRules(Entity x) => x switch {     \/\/ (a * f(x)) * g(x) = a * (f(x) * g(x))     Mulf(Mulf(Number const1, Function func1), Function func2) => func1 * func2 * const1,      \/\/ (a\/b) * (c\/d) = (a*c)\/(b*d)     Mulf(Divf(var any1, var any2), Divf(var any3, var any4)) => any1 * any3 \/ (any2 * any4),      \/\/ a \/ (b \/ c) = a * c \/ b     Divf(var any1, Divf(var any2, var any3)) => any1 * any3 \/ any2,<\/code><\/pre>\n
    (it is a few examples of patterns used in the simplification algorithm)<\/p>\n
    Math<\/h3>\n
    Here I am going to over over features related to math itself.<\/p>\n
    New functions<\/h4>\n
    Secant<\/code>, cosecant<\/code>, arcsecant<\/code>, arccosecant <\/code>were added as separate nodes.<\/p>\n
    12 hyperbolic functions were added. They do not have their own nodes and return their symbolic expression (sinh(x)<\/code>as(e.Pow(x) - e.Pow(-x)) \/ 2<\/code>).<\/p>\n
    Abs <\/code>and Signum<\/code>. The syntax of Abs <\/code>is the following: (|x|)<\/code>. It looks similar to how we write in on a paper while at the same time allows to avoid ambiguouty (because | is symmetric, there might be problems with it).<\/p>\n
    Euler’s totient function was added.<\/p>\n
    WriteLine(@\"phi(8)\".EvalNumerical()); WriteLine(@\"(|-3 + 4i|)\".EvalNumerical()); WriteLine(@\"sinh(3)\".Simplify()); WriteLine(@\"sec(0.5)\".Simplify());<\/code><\/pre>\n
    Prints<\/p>\n
    4 5 (e ^ 3 - 1 \/ e ^ 3) \/ 2 sec(1\/2)<\/code><\/pre>\n
    Domains<\/h4>\n
    They allow to limit every node’s range. If a node is out of its domain, it turns into a NaN<\/code>, which makes the entire expression undefined. SpecialSet<\/code>s are used as values of domains.<\/p>\n
    Booleans and logic<\/h4>\n
    Logic operators were finally added. At the beginning, there was an idea to make those similar to what we use in programming; instead, it was decided to make them literal. That is why the syntax is: not<\/code>, or<\/code>, xor<\/code>, and<\/code>, implies<\/code>.<\/p>\n
    To check whether an expression is evaluable into a Boolean<\/code>, you need to use EvaluableBoolean<\/code>. Same way, we use EvaluableNumerical <\/code>to check whether an expression is evaluable into a Number<\/code>.<\/p>\n
    WriteLine(@\"(true or b) implies c\".Simplify());<\/code><\/pre>\n
    (printsc<\/code>)<\/p>\n
    Equality and inequality signs<\/h4>\n
    They might carry the Boolean<\/code>type, if their operands are computed. Of course, the following were added: =<\/code>, <<\/code>, ><\/code>, <=<\/code>, >=<\/code>.<\/p>\n
    You can also combine inequalities. For example, a > b > c<\/code> is interpreted asa > b and b > c<\/code>.<\/p>\n
    WriteLine(@\"a < b >= c\".Simplify());<\/code><\/pre>\n
    (Printsa < b and b >= c<\/code>)<\/p>\n
    Sets<\/h4>\n
    Sets were added. They are parsable and have their own nodes.<\/p>\n
    The most naive type of set is FiniteSet<\/code>. Its syntax: { 1, 2, 3 }<\/code>.<\/p>\n
    Intervals <\/code>also have familiar syntax: [1; 2]<\/code> for both points included, (1; 2)<\/code> for both excluded, [1; 2)<\/code> for the right one excluded, and (1; 2]<\/code> for the left one excluded. Complex intervals were removed because of their clumsiness.<\/p>\n
    SpecialSet <\/code>are preset sets. Now we have CC<\/code>, RR<\/code>, QQ<\/code>, ZZ<\/code>, BB<\/code>\u00a0for complex, real, rational, integer and boolean values.<\/p>\n
    ConditionalSet <\/code>is written in set-builder notation<\/a>, for example: { x : x > 0 and x^2 = y }<\/code> (any  x<\/code> such that greater than 0 and equalsy<\/code>).<\/p>\n
    WriteLine(@\"({ 1, 2 } \\\/ { 5 }) \/\\ { x : x in [2; 3] and x > 0 } \".Simplify());<\/code><\/pre>\n
    (Prints{ 2 }<\/code>)<\/p>\n
    Limits improved<\/h4>\n
    First remarkable, second remarkable limits transformation rules were added, as well as the l’Hopital’s rule.<\/p>\n
    WriteLine(\"tan(a x) \/ (b x)\".Limit(\"x\", 0)); WriteLine(\"(sin(t) - t) \/ t3\".Limit(\"t\", 0));<\/code><\/pre>\n
    (Printsa \/ b<\/code> and -1\/6<\/code> respectively)<\/p>\n
    «Provided» node<\/h4>\n
    Allows to set constraints on an expression. For example, square root on real numbers we can define as sqrt(x) provided x >= 0<\/code>. It will turn into NaN <\/code>if you substitute negative x<\/code>.<\/p>\n
    If an expression being turned into NaN <\/code>is an element of a finite set, it will be excluded, instead of turning the whole expression into NaN<\/code>. It is the only exception for NaN<\/code>.<\/p>\n
    Piecewise<\/h4>\n
    Piecewise <\/code>is a sequence ofProvided<\/code>s. Unlike the classical piecewise-defined function, here the order of elements matters, and when computingPiecewise<\/code>, the firstProvided<\/code>\u00a0is returned such that its predicate is true.<\/p>\n
    That is an example of how we can define the absolute value function for real numbers via Piecewise<\/code>:<\/p>\n
    Entity abs = \"piecewise(x provided x > 0, -x provided x <= 0)\"; WriteLine(abs.Substitute(\"x\", 3).EvalNumerical()); WriteLine(abs.Substitute(\"x\", -3).EvalNumerical());<\/code><\/pre>\n
    (Prints 3 in both cases)<\/p>\n
    Ease and convenience of use<\/h2>\n
    This part of the article about features making the use of AngouriMath more comfortable.<\/p>\n
    Exceptions were reconsidered and refactored<\/h4>\n
    Now all exceptions thrown by the library are somehow inherited from AngouriMathBaseException<\/code>. Because there is nop\/invoke<\/code> or IO, you can be assured that any exception assignable to AngouriMathBaseException\u00a0<\/code>does not bring any direct harm to the system or user’s data. In other words, when catching exceptions, now you can catch this exception in the last instance of Catch<\/code>.<\/p>\n
    Performance improved<\/h4>\n
    To be precise, the performance has been fluctuating throughout this all time. Nonetheless, it is still by far better than that of 1.1.0.5. Here <\/a>you can find a performance report by every key commit.<\/p>\n
    F# is now supported<\/h4>\n
    With this release, the API for AngouriMath is now supported natively for wonderful language F#. It might be not as functional as the main API, so in especially complicated cases, you still can call methods from the core library itself.<\/p>\n
    Interactive<\/h4>\n
    I wrote an article some time ago about AngouriMath in Jupyter<\/a>. AngouriMath.Interactive itself simplify converts ILatexiseable <\/code>into a LaTeX-code and renders it with MathJax (read more about it in the mentioned article).<\/p>\n
    A simple example of using AngouriMath.Interactive in Jupyter<\/figcaption><\/figure>\n
    Multithreading<\/h4>\n
    All computations happen strictly in one thread. The library is not responsible for your threading problems. Moreover, all methods are thread-safe. The settings are local for every thread([ThreadStatic]<\/code>).<\/p>\n
    The main feature of this update is that you can interrupt computations of Solve <\/code>orSimplify<\/code>. <\/p>\n
    New settings<\/h4>\n
    It is their third version. Even though I am not a big fan of the new solution, it is the best I could achieve. To set a new value of a setting, let us write<\/p>\n
    using var _ = MaxExpansionTermCount.Set(10); \/\/ some code<\/code><\/pre>\n
    Then this setting will be automatically rolled back to the previous value once the end of the scope is reached (the return type of Set<\/code>\u00a0isIDisposable<\/code>).<\/p>\n
    That is about it<\/h3>\n
    Thank you for your attention. I will be pleased to answer your questions.<\/p>\n
    Anybody willing to contribute is welcome (contact me or fork and make your changes directly).<\/p>\n
    References<\/h3>\n
      \n
    1. \n
      GitHub<\/a> page of the project.<\/p>\n<\/li>\n
    2. \n
      Website<\/a> of the project.<\/p>\n<\/li>\n
    3. \n
      Detailed What’s new<\/a>.<\/p>\n<\/li>\n
    4. \n
      Plans<\/a> for the future updates.<\/p>\n<\/li>\n
    5. \n
      My GitHub profile<\/a>.<\/p>\n<\/li>\n
    6. \n
      SymPy <\/a>— those who inspire me.<\/p>\n<\/li>\n<\/ol>\n<\/div>\n<\/div>\n<\/div>\n
      <\/div>\n

       \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438        https:\/\/habr.com\/ru\/articles\/545436\/<\/a>
      <\/br><\/br><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-400330","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/400330","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=400330"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/400330\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=400330"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=400330"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=400330"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}