Overzealous parser check that disabled nested stats fixed

Sorry, v1.1.3 tag was not pushed.
This release is targeted at an overzealous check in the parser that disabled the nested stats functionality e.g.
sort(1,2,3,listsum(4,5,9),2,8) should start working again now

Full Changelog: v1.1.2...v1.1.4

MatrixTurboEvaluator support for rot function

What's Changed

• Returned original readme, and linked from main readme by @judovana in #44
• Added jdk21+25 to gh workgflows by @judovana in #45
• Version 1.1.2 fixes bugs and makes MatrixTurboEvaluator natively support turbo execution of the rot function. Note that the ScalarTurboEvaluators already support it.
• FastCompositeExpression is now aware of its compiler as it now sports a getCompiler default method(which can be overriden to specify the turbo class that compiled it)

Full Changelog: v1.1.1...v1.1.2

Dynamic Version Implemented

Full Changelog: v1.1.0...v1.1.1

Dynamic Version Computation At runtime implemented

Rotor Function and ErrorLog upgrades

Bug fixes in Rotor and ErrorLog. Matrix of Points upgrade for Rotor

1. The rotor function(rot) has been upgraded to take an argument of a Matrix of Nx3 points to be rotated. It then outputs a Matrix of Nx3 rotated points.
2. There were bug fixes also in the handling of the rotation of functions. When a function is rotated now, the user is handed the output to solve or make the y(vertical coordinates) the subject of the formula, because the output is generally an implicit function.
3. Two point function rotation still supported for backwards compatibility.
4. ErrorLog upgraded

Full Changelog: v1.0.8...v1.1.0

Turbo-Android-Compatibility-Fixes

Full Changelog: v1.0.4...v1.0.8
1.0.8
Bug fixes and more Android compatibility issues resolved.

1.0.6
Bug fixes and Android compatibility issues resolved.

1.0.5
Features bug fixes and optimizations in the scanning/semantic analysis stages.

Turbo Upgrades

What's Changed

• Turbo Mode by @gbenroscience in #40
• text fixes by @gbenroscience in #41
• save by @gbenroscience in #42

Full Changelog: v1.0.1...v1.0.4

1.0.4
This version features various optimizations and turbo capability for the Function class.

1.0.3
Maintaining the industry standard besting speeds of v1.0.x, it adds the functionality of rotational geometry. In v1.0.3, you can use the rotor function, rot to rotate raw points in 3D space and other functions such as curves, lines, surfaces(both plane and curved) and 3D equations of all sorts.

1.0.2
Adds an extra widening technique of variable passing to the Turbo mode, In addition to the current method of array based passing. The widening technique can be sometimes faster than the array based methods, but their speed profiles and memory profiles are similar. Its weakness though is that it cannot use more than 63 variables per expression, whereas the array based approach allows in theory any number up to the max integer size.

1.0.1
This close update ensures that Turbo mode's memory profile stays close to that of the normal mode, which is, nigh zero.

heavy speed upgrade with turbo mode

The library has finally come of age with the introduction of its Turbo mode, which offers a massive speed boost over its normal mode. The nomal mode already beats famous libraries like exp4J, and rivals Janino, the widely acclaimed Gold Standard of Java math parser speed measurements, very closely

Full Changelog: v0.2.5...v1.0.0

v0.2.5

https://github.com/gbenroscience/ParserNG/compare/v0.2.4..v0.2.5

Functions like intg, root, t_root and quadratic have been fixed and are working well. .

Frame based args passing is used to milk the last drops of performance during iterations.

Constant folding and strength reduction make the evaluation process feel much faster.

The print function that can be used to view the contents of an EvalResult which the solveGeneric() method returns is also functional.

If you need a rich, fully featured parser that can do 3 million to 10 million evaluations per second, ParserNG v0.2.5 is the one for you.

Full Changelog: v0.2.4...v0.2.5

speed-upgrade-04

Full Changelog: v0.2.3...v0.2.4
ParserNG 0.2.4 drives the limits of expression interpretation velocity even further than all previous versions, beating many lighterweight and fast Java math parsers(interpreted) in many benchmarks.
Check ParserNG-Wars for some shootouts between ParserNG and other parsers, both handrafted benchmarks and JMH based ones

ParserNG evaluates expressions at almost the speed at which the expressions would run if they were compiled statements in Java code. Typical values for moderate expression evaluation speeds are between 85ns(algebraic expressions e.g.((12+5)*3 - (45/9))^2 to 176ns(methods with trig. functions, e.g. (sin(3) + cos(4 - sin(2))) ^ (-2)).

Applications that need 5 million to 10 million points generated per second would benefit from ParserNG v0.2.4

speed-upgrade-03

Full Changelog: v0.2.2...v0.2.3
Comes with couple microsecond (on decent hardware and) expression solving ability while maintaining its full feature stack. Graphing feels butter-smooth and iterations shouldn't feel so iterative.

At 5 microsecond, moderately complex expressions such as

String s6 = "5sin(3+2)/(43-2)";
can be evaluated almost 200 thousand times per second.

The model of a Matrix has also been optimized to use a 1D array internally. This makes it faster due to memory locality of Matrix data.

Also, we support eigenvalues and eigenvectors as inbuilt methods, so enjoy!

Full Changelog: v0.2.2...v0.2.3