save

Author: gbenroscience

LATEST.md

@@ -1,6 +1,13 @@
 # ParserNG
 
 
+### Parser 1.0.6 has been released on maven-central!
+Bug fixes and Android compatibility issues resolved.
+
+
+### Parser 1.0.5 has been released on maven-central!
+Features bug fixes and optimizations in the scanning/semantic analysis stages.
+
 ### Parser 1.0.4 has been released on maven-central!
 This version features various optimizations and turbo capability for the Function
 class.

MORE.md

@@ -1,5 +1,5 @@
 # ParserNG
-<b>ParserNG</b> is a powerful open-source math tool that parses and evaluates algebraic expressions and also knows how to handle a lot of mathematical expressions. Its latest release on mavn-central (version 1.0.5) can be used to plot 2D graphs(Geometric plots and function plots) It works seamlessly on all Java platforms.<br><br>
+<b>ParserNG</b> is a powerful open-source math tool that parses and evaluates algebraic expressions and also knows how to handle a lot of mathematical expressions. Its latest release on mavn-central (version 1.0.6) can be used to plot 2D graphs(Geometric plots and function plots) It works seamlessly on all Java platforms.<br><br>
 
 
 
@@ -8,15 +8,15 @@
       Click the Sponsor button to do this.
 
 
-ParserNG v1.0.5 breaks the barrier in fully featured math parser frequencies!
-With various other optimizations, v1.0.5 comes with inner loop optimizations which uses a blazing fast, post-fix style algorithm to quickly evaluate inner brackets with less checks and less string manipulations.
+ParserNG v1.0.6 breaks the barrier in fully featured math parser frequencies!
+With various other optimizations, v1.0.6 comes with inner loop optimizations which uses a blazing fast, post-fix style algorithm to quickly evaluate inner brackets with less checks and less string manipulations.
 This obviously will make graphing and other iterative tasks super responsive.
 
-ParserNG v1.0.5 is an extremely feature rich math tool which also doubles as (arguably) the fastest pure Java expression evaluator on the planet.
+ParserNG v1.0.6 is an extremely feature rich math tool which also doubles as (arguably) the fastest pure Java expression evaluator on the planet.
 In benchmarks, it beats com.expression.parser(Java Math Expression Parser) by almost (10x-14x) and edges out Exp4J (which is lightweight) in many benchmarks.
 
 
-ParserNG 1.0.5 features strength reduction, constant folding and execution frame(array) based args passing(in contrast to Map based) to ensure O(1) complexity in passage of args to the evaluation stage.
+ParserNG 1.0.6 features strength reduction, constant folding and execution frame(array) based args passing(in contrast to Map based) to ensure O(1) complexity in passage of args to the evaluation stage.
 
 [Here are a few benchmarks here](./BENCHMARK_RESULTS.md)
 
@@ -68,7 +68,7 @@ If you need to access this library via Maven Central, do:
         <dependency>
             <groupId>com.github.gbenroscience</groupId>
             <artifactId>parser-ng</artifactId>
-            <version>1.0.5</version>
+            <version>1.0.6</version>
         </dependency>
        
 
@@ -101,20 +101,20 @@ ParserNG is written completely in (pure) Java and so is as cross-platform as Jav
 ## Using ParserNG as commandline tool
 You can use jar directly as commandline calculus. Unless the tool is packed to your distribution:
 ```
-java -jar parser-ng-1.0.5.jar  1+1
+java -jar parser-ng-1.0.6.jar  1+1
 2.0
 ```
 Or as logical parser
 ```
-java -jar parser-ng-1.0.5.jar -l true and true
+java -jar parser-ng-1.0.6.jar -l true and true
 true
-java -jar parser-ng-1.0.5.jar -l "2 == (4-2)"
+java -jar parser-ng-1.0.6.jar -l "2 == (4-2)"
 true
 ```
 You can get help by 
 ```
-java -jar parser-ng-1.0.5.jar  -h
-  ParserNG 1.0.5 math.Main
+java -jar parser-ng-1.0.6.jar  -h
+  ParserNG 1.0.6 math.Main
 -h/-H/--help         this text; do not change for help (witout dashes), which lists functions
 -v/-V/--verbose      output is reprinted to stderr with some inter-steps
 -l/-L/--logic        will add logical expression wrapper around the expression
@@ -136,11 +136,11 @@ java -jar parser-ng-1.0.5.jar  -h
 ```
 You  can get examples by verbose help:
 ```
-java -jar parser-ng-1.0.5.jar  -h -v
+java -jar parser-ng-1.0.6.jar  -h -v
 ```
 you can list functions:
 ```
-java -jar parser-ng-1.0.5.jar  help
+java -jar parser-ng-1.0.6.jar  help
 List of currently known methods:
 acos        - help not yet written. See https://github.com/gbenroscience/ParserNG
 ...
@@ -149,7 +149,7 @@ List of functions is just tip of iceberg, see: https://github.com/gbenroscience/
 ```
 you can list logical operators:
 ```
-java -jar parser-ng-1.0.5.jar  -l help
+java -jar parser-ng-1.0.6.jar  -l help
 Comparing operators: !=, ==, >=, <=, le, ge, lt, gt, <, >
 Logical operators: impl, xor, imp, eq, or, and, |, &
 As Mathematical parts are using () as brackets, Logical parts must be grouped by [] eg.
@@ -164,40 +164,40 @@ Program can work with stdin, out and err properly. Can work with multiline input
 ### cmdline examples
 Following lines describes, how stdin/arguments are processed, and how different is input/output with `-t` on/off
 ```
-   java -jar parser-ng-1.0.5.jar -h
+   java -jar parser-ng-1.0.6.jar -h
     this help
-  java -jar parser-ng-1.0.5.jar 1+1
+  java -jar parser-ng-1.0.6.jar 1+1
     2.0
-  java -jar parser-ng-1.0.5.jar "1+1
+  java -jar parser-ng-1.0.6.jar "1+1
                                  +2+2"
     2.0
     4.0
-  java -jar parser-ng-1.0.5.jar -t "1+1
+  java -jar parser-ng-1.0.6.jar -t "1+1
                                     +2+2"
     6.0
-  java -jar parser-ng-1.0.5.jar -i  1+1
+  java -jar parser-ng-1.0.6.jar -i  1+1
     nothing, will expect manual output, and calculate line by line
-  java -jar parser-ng-1.0.5.jar -i -t  1+1
+  java -jar parser-ng-1.0.6.jar -i -t  1+1
     nothing, will expect manual output and calcualte it all as one expression
-  echo 2+2 | java -jar parser-ng-1.0.5.jar  1+1
+  echo 2+2 | java -jar parser-ng-1.0.6.jar  1+1
     2.0
   echo "1+1 
-        +2+2 | java -jar parser-ng-1.0.5.jar -i
+        +2+2 | java -jar parser-ng-1.0.6.jar -i
     2.0
     4.0
   echo "1+1 
-        +2+2 | java -jar parser-ng-1.0.5.jar -i -t
+        +2+2 | java -jar parser-ng-1.0.6.jar -i -t
     6.0
-  java -cp parser-ng-1.0.5.jar parser.cmd.ParserCmd "1+1
+  java -cp parser-ng-1.0.6.jar parser.cmd.ParserCmd "1+1
     will ask for manual imput en evaluate per line
   echo "1+1 
-        +2+2 | java -cp parser-ng-1.0.5.jar parser.cmd.ParserCmd 2>/dev/null
+        +2+2 | java -cp parser-ng-1.0.6.jar parser.cmd.ParserCmd 2>/dev/null
     2.0
     4.0
-  java -cp parser-ng-1.0.5.jar parser.MathExpression "1+1
+  java -cp parser-ng-1.0.6.jar parser.MathExpression "1+1
                                                       +2+2"
     6.0
-  java -cp parser-ng-1.0.5.jar parser.LogicalExpression "true or false"
+  java -cp parser-ng-1.0.6.jar parser.LogicalExpression "true or false"
     true
 
 ```
@@ -773,7 +773,7 @@ This would give:
 
 #### ParserNG and eigenvalues
 
-Version 1.0.5 of ParserNG allows you to quickly compute the eigenvalues of a Matrix.
+Version 1.0.6 of ParserNG allows you to quickly compute the eigenvalues of a Matrix.
 
 Do:
 ```Java
@@ -782,7 +782,7 @@ Do:
 ```
 #### ParsrNG and eigenvectors
 
-As of ParserNG 1.0.5 also, eigenvector computations have been added, do:
+As of ParserNG 1.0.6 also, eigenvector computations have been added, do:
 Do:
 ```Java
     MathExpression expression = new MathExpression("eigvec(@(5,5)(12,1,4,2,9,3,1,8,-5,6,13,9,7,3,5,7,3,5,4,9,13,2,4,8,6))");

README.md

@@ -1,6 +1,6 @@
 # ParserNG 🧮⚡
 
-**ParserNG 1.0.5** is a **blazing-fast**, nigh zero allocation(memory wise), **pure Java**, **zero-native-dependencies** math expression parser and evaluator.
+**ParserNG 1.0.6** is a **blazing-fast**, nigh zero allocation(memory wise), **pure Java**, **zero-native-dependencies** math expression parser and evaluator.
 
 It **beats exp4J, and com.expression.parser on evaluation speed** across every kind of expression — from simple algebra to heavy trig, matrices, and calculus; and manages to beat Janino, the gold standard on some, while rivalling it on a host of other expressions  
 The normal mode routinely does about **3-10 million evaluations per second** while the new Turbo mode easily peaks at about **10 million to 90 million evaluations per second**.
@@ -12,11 +12,11 @@ Perfect for scientific computing, simulations, real-time systems, education tool
 [![Maven Central](https://img.shields.io/maven-central/v/com.github.gbenroscience/parser-ng.svg?label=Maven%20Central)](https://central.sonatype.com/artifact/com.github.gbenroscience/parser-ng)
 [![License](https://img.shields.io/github/license/gbenroscience/ParserNG?color=blue)](https://github.com/gbenroscience/ParserNG/blob/master/LICENSE)
 ![Java](https://img.shields.io/badge/Java-8%2B-orange)
-![Latest Version](https://img.shields.io/badge/version-1.0.5-success)
+![Latest Version](https://img.shields.io/badge/version-1.0.6-success)
 
-> **1.0.5** introduces **Turbo Scalar** and **Turbo Matrix** compiled paths + massive speed improvements via strength reduction, constant folding, and O(1) frame-based argument passing.
+> **1.0.6** introduces **Turbo Scalar** and **Turbo Matrix** compiled paths + massive speed improvements via strength reduction, constant folding, and O(1) frame-based argument passing.
 
-## ✨ Highlights (v1.0.5)
+## ✨ Highlights (v1.0.6)
 
 - **Speed champion** — rivals Janino in most benchmarks, and beats exp4J, com.expression.parser and Parsii in every benchmark (see [BENCHMARK_RESULTS.md](BENCHMARK_RESULTS.md))
 - **Turbo Mode** — compile once, evaluate millions of times per second (Scalar + Matrix paths)
@@ -36,14 +36,14 @@ Perfect for scientific computing, simulations, real-time systems, education tool
 <dependency>
     <groupId>com.github.gbenroscience</groupId>
     <artifactId>parser-ng</artifactId>
-    <version>1.0.5</version>
+    <version>1.0.6</version>
 </dependency>
 ```
 
 Also available on **Maven Central**:  
-https://central.sonatype.com/artifact/com.github.gbenroscience/parser-ng/1.0.5
+https://central.sonatype.com/artifact/com.github.gbenroscience/parser-ng/1.0.6
 
-## ⚡ Turbo Mode — The 1.0.5 Game Changer
+## ⚡ Turbo Mode — The 1.0.6 Game Changer
 
 ```java
 import com.github.gbenroscience.parser.MathExpression;
@@ -158,10 +158,10 @@ with the directio vector,(1,1,0). The angle of rotation is pi radians.
 ## ⌨️ Command-line tool (REPL)
 
 ```bash
-java -jar parser-ng-1.0.5.jar "sin(x) + cos(x)"
-java -jar parser-ng-1.0.5.jar "eigvalues(R=@(5,5)(...))"
-java -jar parser-ng-1.0.5.jar help
-java -jar parser-ng-1.0.5.jar -i          # interactive mode
+java -jar parser-ng-1.0.6.jar "sin(x) + cos(x)"
+java -jar parser-ng-1.0.6.jar "eigvalues(R=@(5,5)(...))"
+java -jar parser-ng-1.0.6.jar help
+java -jar parser-ng-1.0.6.jar -i          # interactive mode
 ```
 
 ## 📊 Supported Features at a Glance
@@ -182,8 +182,8 @@ Full list: run `help` or `new MathExpression("help").solve()`.
 
 - [BENCHMARK_RESULTS.md](BENCHMARK_RESULTS.md) — full speed comparisons
 - [GRAPHING.md](GRAPHING.md) — plotting on Swing / JavaFX / Android
-- [LATEST.md](LATEST.md) — what’s new in 1.0.5
-- Javadoc: https://javadoc.io/doc/com.github.gbenroscience/parser-ng/1.0.5
+- [LATEST.md](LATEST.md) — what’s new in 1.0.6
+- Javadoc: https://javadoc.io/doc/com.github.gbenroscience/parser-ng/1.0.6
 
 ## ❤️ Support the Project
 
@@ -200,7 +200,7 @@ ParserNG is built with love in my free time. If it helps you:
 
 ---
 
-**ParserNG 1.0.5** — faster than the competition, stronger on matrices, and now with real Turbo Scalar + Turbo Matrix compiled power.
+**ParserNG 1.0.6** — faster than the competition, stronger on matrices, and now with real Turbo Scalar + Turbo Matrix compiled power.
 
 Happy parsing! 🚀  
 — **GBENRO JIBOYE** (@gbenroscience)

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.github.gbenroscience</groupId>
     <artifactId>parser-ng</artifactId>
-    <version>1.0.5</version>
+    <version>1.0.6</version>
     <packaging>jar</packaging>
     <!-- 
       I started this project 2009 and have been upgrading it since then.
@@ -14,8 +14,8 @@
     <name>ParserNG</name>
     <description>Rich and Performant, Cross Platform Java Library(100% Java).No native dependencies. 
         ParserNG is the height of interpreted Math parsing in Java. It is the fastest of all interpreted Java math parsers.
-        Version 1.0.5 retains high frequency execution and multi-mode/multi-functional nature
-        Fixes bugs in the rot function and optimizes some inner loops during syntax and semantic analysis for speedier parsing
+        Version 1.0.6 retains high frequency execution and multi-mode/multi-functional nature, but targets the Android environment's limited
+        implementation of MethodHandles and makes turbo mode work on Android.
     </description>
     <url>https://github.com/gbenroscience/ParserNG</url>
 

src/main/java/com/github/gbenroscience/math/geom/ROTOR.java

@@ -595,7 +595,7 @@ public String rotate(String function) {
                 // Wrapping in parentheses preserves the Order of Operations
                 if (replacement.charAt(0) == '(' && replacement.charAt(replacement.length() - 1) == ')') { 
                     sb.append(replacement);
-                } else { 
+                } else {
                     sb.append("(").append(replacement).append(")");
                 }
             } else {

src/main/java/com/github/gbenroscience/parser/Function.java

@@ -17,6 +17,7 @@
 import com.github.gbenroscience.util.FunctionManager;
 import static com.github.gbenroscience.util.FunctionManager.*;
 import com.github.gbenroscience.util.Serializer;
+import com.github.gbenroscience.util.Utils;
 import com.github.gbenroscience.util.VariableManager;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -309,8 +310,8 @@ public static boolean assignObject(String input) {
                     } else {
                         anonFunc.dependentVariable = new Variable(newFuncName);
                     }
-                    
-                        FunctionManager.update(anonFunc);
+
+                    FunctionManager.update(anonFunc);
                     return true;
                 } else {
                     expr = new MathExpression(rhs);
@@ -487,9 +488,9 @@ else if (Number.isNumber(tkn)) {
             //input = dependentVar + "="+input;
             anonFn.setDependentVariable(new Variable(dependentVar));
             anonFn.setIndependentVariables(indVars);
-            anonFn.type = TYPE.ALGEBRAIC_EXPRESSION; 
+            anonFn.type = TYPE.ALGEBRAIC_EXPRESSION;
             MathExpression me = new MathExpression(expr);
-            
+
             anonFn.setMathExpression(me);
             //FunctionManager.update(anonFn);
         } else if (isMatrix) {
@@ -580,20 +581,20 @@ public Variable getDependentVariable() {
     }
 
     public void setMathExpression(MathExpression mathExpression) {
-        MathExpression oldMe = this.mathExpression;
         try {
             this.mathExpression = mathExpression;
-            this.turboExpr = TurboEvaluatorFactory.getCompiler(mathExpression, false).compile();
             this.type = TYPE.ALGEBRAIC_EXPRESSION;
+            this.turboExpr = TurboEvaluatorFactory.getCompiler(mathExpression, false).compile();
         } catch (Throwable ex) {
-            //revert
-            this.mathExpression = oldMe;
             this.turboExpr = null;
             Logger.getLogger(Function.class.getName()).log(Level.SEVERE, null, ex);
         }
     }
 
     public FastCompositeExpression getWideningArgsExpression() {
+        if (Utils.isAndroid()) {
+            throw new RuntimeException("Not allowed on Android! Use Function#getArrayArgsExpression()");
+        }
         try {
             this.turboExpr = TurboEvaluatorFactory.getCompiler(mathExpression, true).compile();
         } catch (Throwable ex) {
@@ -1404,22 +1405,35 @@ public static void main(String args[]) {
         func.updateArgs(4);
         System.out.println(func.calc());
 
-        int count = 10000;
+        int count = 100000;
 
         double start = System.nanoTime();
+        String val = null;
         for (int i = 1; i <= count; i++) {
-            String val = func.evalArgs("p(" + i + ")");
-            System.out.println("val = " + val);
-            System.out.println(func.evalArgs(i));
+            val = func.evalArgs(i);
         }
         double duration = System.nanoTime() - start;
-        System.out.println("Eval took: " + (duration / (count * 1.0E6)) + "ms");
+        System.out.println("Std-Eval took: " +  duration/count  + "ns");
+        System.out.println("val1 = " + val);
 
+        start = System.nanoTime();
         for (int i = 1; i <= count; i++) {
-            String val = func.evalArgs("p(" + i + ")");
+            val = func.evalArgs("p(" + i + ")");
         }
+        System.out.println("val2 = " + val);
+
+        duration = System.nanoTime() - start;
+        System.out.println("Old-Eval took: " + (duration / (count * 1.0E6)) + "ms");
+        
+        double v = 0;
+        start = System.nanoTime();
+        for (int i = 1; i <= count; i++) {
+            v = func.evalArgsTurbo(i);
+        }
+        System.out.println("val3 = " + v);
+
         duration = System.nanoTime() - start;
-        System.out.println("Eval took: " + (duration / (count * 1.0E6)) + "ms");
+        System.out.println("Turbo-Eval took: " + duration/count + "ns");
 
     }//end method