fixed 24B/Op memory issue in 1.0.0, will push 1.0.1

Author: gbenroscience

LATEST.md

@@ -1,5 +1,9 @@
 # ParserNG
 
+ParserNG 1.0.0 has been released on maven-central!
+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
+
 
 ParserNG 0.2.5 has been released on maven-central
 

README.md

@@ -1,8 +1,8 @@
 # ParserNG 🧮⚡
 
-**ParserNG 1.0.0** is a **blazing-fast**, **pure Java**, **zero-native-dependencies** math expression parser and evaluator.
+**ParserNG 1.0.1** is a **blazing-fast**, **pure Java**, **zero-native-dependencies** math expression parser and evaluator.
 
-It **beats Janino, exp4J, and JavaMEP on evaluation speed** across every kind of expression — from simple algebra to heavy trig, matrices, and calculus.  
+It **beats Janino, exp4J, and com.expression.parser on evaluation speed** across every kind of expression — from simple algebra to heavy trig, matrices, and calculus.  
 With the new **Turbo compiled mode**, it routinely reaches **3–10 million evaluations per second**.
 
 It goes far beyond basic parsing — offering **symbolic differentiation**, **resilient numerical integration**, **full matrix algebra**, **statistics**, **equation solving**, **user-defined functions**, **2D graphing**, and more — all in one lightweight, cross-platform library.

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.github.gbenroscience</groupId>
     <artifactId>parser-ng</artifactId>
-    <version>1.0.0</version>
+    <version>1.0.1</version>
     <packaging>jar</packaging>
     <!-- 
       I started this project 2009 and have been upgrading it since then.
@@ -13,6 +13,8 @@
 
     <name>ParserNG</name>
     <description>Rich and Performant, Cross Platform Java Library(100% Java)...Version 1.0.0 explodes even higher in execution speed.
+        Version 1.0.1 retains the wild speeds of Version 1.0.0 and brings the memory usage of the turbo mode down to 0.001 B/op(same as for the normal mode)
+        but at nanosecond speeds.Matrix Algebra and other rich features have been optimized in Turbo mode also.
         </description>
     <url>https://github.com/gbenroscience/ParserNG</url>
 

src/main/java/com/github/gbenroscience/parser/turbo/tools/ScalarTurboEvaluator.java

@@ -72,7 +72,6 @@ public class ScalarTurboEvaluator implements TurboExpressionEvaluator {
             MethodType vectorType = MethodType.methodType(double[].class, String.class, double[].class);
             MethodType vector2Type = MethodType.methodType(double[].class, String.class, String.class);
 
-            // Find the static methods
             /**
              * For non stats methods that return a double array
              */
@@ -193,23 +192,52 @@ public static double invokeRegistryMethod(int methodId, double[] argsValues) {
      *
      * @return A FastCompositeExpression that returns wrapped scalar
      * @throws Throwable if compilation fails
+     *
+     * @Override public FastCompositeExpression compile() throws Throwable { //
+     * This now yields a handle with signature (double[])Object MethodHandle
+     * scalarHandle = compileScalar(postfix);
+     *
+     * return new FastCompositeExpression() {
+     * @Override public MathExpression.EvalResult apply(double[] variables) {
+     * try { // invoke() now returns Double (boxed) or double[] Object result =
+     * scalarHandle.invoke(variables);
+     *
+     * if (result instanceof double[]) { return new
+     * MathExpression.EvalResult().wrap((double[]) result); } return new
+     * MathExpression.EvalResult().wrap(((Number) result).doubleValue()); }
+     * catch (Throwable t) { throw new RuntimeException("Turbo evaluation
+     * failed", t); } }
+     *
+     * @Override public double applyScalar(double[] variables) { try { Object
+     * result = scalarHandle.invoke(variables);
+     *
+     * if (result instanceof Number) { return ((Number) result).doubleValue(); }
+     * // Coercion: If the user calls a vector function in a scalar context, //
+     * we return the first element to prevent a crash. double[] arr = (double[])
+     * result; return (arr != null && arr.length > 0) ? arr[0] : Double.NaN; }
+     * catch (Throwable t) { throw new RuntimeException("Turbo primitive
+     * execution failed", t); } } }; }
      */
     @Override
     public FastCompositeExpression compile() throws Throwable {
-        // This now yields a handle with signature (double[])Object
-        MethodHandle scalarHandle = compileScalar(postfix);
+        // The base handle as defined by your compiler (returns Object)
+        MethodHandle genericHandle = compileScalar(postfix);
+
+        // Specialized handle for scalar path: (double[])double
+        // This forces the JIT to see the primitive return path
+        MethodHandle scalarPrimitiveHandle = genericHandle.asType(
+                MethodType.methodType(double.class, double[].class));
 
         return new FastCompositeExpression() {
             @Override
             public MathExpression.EvalResult apply(double[] variables) {
                 try {
-                    // invoke() now returns Double (boxed) or double[]
-                    Object result = scalarHandle.invoke(variables);
-
+                    // Keep Object for the general/vector path
+                    Object result = genericHandle.invokeExact(variables);
                     if (result instanceof double[]) {
                         return new MathExpression.EvalResult().wrap((double[]) result);
                     }
-                    return new MathExpression.EvalResult().wrap(((Number) result).doubleValue());
+                    return new MathExpression.EvalResult().wrap((double) result);
                 } catch (Throwable t) {
                     throw new RuntimeException("Turbo evaluation failed", t);
                 }
@@ -218,15 +246,18 @@ public MathExpression.EvalResult apply(double[] variables) {
             @Override
             public double applyScalar(double[] variables) {
                 try {
-                    Object result = scalarHandle.invoke(variables);
-
-                    if (result instanceof Number) {
-                        return ((Number) result).doubleValue();
+                    // Use invokeExact on the specialized primitive handle
+                    // This will result in ZERO allocations
+                    return (double) scalarPrimitiveHandle.invokeExact(variables);
+                } catch (ClassCastException cce) {
+                    // Fallback for cases where the result is actually a double[] 
+                    // but called in a scalar context
+                    try {
+                        double[] arr = (double[]) genericHandle.invokeExact(variables);
+                        return (arr != null && arr.length > 0) ? arr[0] : Double.NaN;
+                    } catch (Throwable t) {
+                        throw new RuntimeException(t);
                     }
-                    // Coercion: If the user calls a vector function in a scalar context,
-                    // we return the first element to prevent a crash.
-                    double[] arr = (double[]) result;
-                    return (arr != null && arr.length > 0) ? arr[0] : Double.NaN;
                 } catch (Throwable t) {
                     throw new RuntimeException("Turbo primitive execution failed", t);
                 }
@@ -331,7 +362,6 @@ private static MethodHandle compileScalar(MathExpression.Token[] postfix) throws
                         String[] rawArgs = t.getRawArgs();
                         stack.pop();
 
- 
                         MethodHandle finalOp = MethodHandles.insertArguments(VECTOR_2_GATEKEEPER_HANDLE, 0, name, rawArgs[0]);
 
 // CRITICAL: You must change the return type to Object.class.
@@ -977,18 +1007,19 @@ private static double[] executeVectorReturningStatsMethod(MethodHandle handle, d
     /**
      * Execution bridge for the TurboRootFinder. This is invoked by the compiled
      * MethodHandle chain.
+     *
      * @param baseHandle
      * @param derivHandle
      * @param xSlot
      * @param iterations
      * @param lower
      * @param upper
-     * @return 
+     * @return
      */
     public static double executeTurboRoot(MethodHandle baseHandle, MethodHandle derivHandle,
             int xSlot, double lower, double upper, int iterations) {
         // We use a default iteration cap of 1000 for the turbo version
-        TurboRootFinder trf = new TurboRootFinder(baseHandle, derivHandle, xSlot, lower, upper, iterations); 
+        TurboRootFinder trf = new TurboRootFinder(baseHandle, derivHandle, xSlot, lower, upper, iterations);
         return trf.findRoots();
     }
 
@@ -1006,8 +1037,8 @@ public static double[] executeQuadraticRoot(String funcHandle) {
         QuadraticSolver alg = solver.getAlgorithm();
         if (alg.isComplex()) {
             return alg.solutions;
-        } else { 
-            return new double[]{alg.solutions[0],alg.solutions[2]};
+        } else {
+            return new double[]{alg.solutions[0], alg.solutions[2]};
         }
     }