optimized bracket cleanups

Author: gbenroscience

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.github.gbenroscience</groupId>
     <artifactId>parser-ng</artifactId>
-    <version>1.0.4</version>
+    <version>1.0.5</version>
     <packaging>jar</packaging>
     <!-- 
       I started this project 2009 and have been upgrading it since then.
@@ -12,8 +12,10 @@
     -->
 
     <name>ParserNG</name>
-    <description>Rich and Performant, Cross Platform Java Library(100% Java)...Version 1.0.3 retains high frequency execution and multi-mode/multi-functional nature
-        And it adds a function, the rotor function, `rot` which allows users to rotates point, lines, planesand cuved surfaces, curves and functions in 3D space. Now you can know what a curve will look like when it is rotated about a certain point in a given direction.
+    <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
     </description>
     <url>https://github.com/gbenroscience/ParserNG</url>
 

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

@@ -20,6 +20,7 @@
 import com.github.gbenroscience.util.VariableManager;
 import static com.github.gbenroscience.parser.Operator.*;
 import static com.github.gbenroscience.parser.Variable.*;
+import com.github.gbenroscience.util.FunctionManager;
 import java.util.*;
 
 /**
@@ -42,22 +43,22 @@
  */
 public class BracketCleaner {
 
+
     // Fast lookup for known functions (covers Method.isMethodName)
     private static final List<String> FUNCTIONS = Arrays.asList(Method.getAllFunctions());
 
     /**
-     * Removes excess brackets **in-place** and returns the same list for convenience.
-     * The input list is modified directly.
+     * Removes excess brackets **in-place**. 
+     * The list you pass in is modified directly — exactly like your original method.
      */
-    public static List<String> removeExcessBrackets(List<String> scanner) {
+    public static void removeExcessBrackets(List<String> scanner) {
         if (scanner == null || scanner.isEmpty()) {
-            return scanner;
+            return;
         }
 
         boolean changed;
         do {
             changed = false;
-            // Build pairMap ONCE per full pass (efficient)
             int[] pairMap = buildPairMap(scanner);
 
             for (int i = 0; i < scanner.size(); i++) {
@@ -68,74 +69,62 @@ public static List<String> removeExcessBrackets(List<String> scanner) {
                 int open = i;
                 int close = pairMap[i];
 
-                // 1. Redundant nested brackets: ((x)) → (x)  (safe even after @, sin, etc.)
+                // 1. Redundant nested brackets ((...)) → (...)   (always safe)
                 if (open + 1 < scanner.size() && pairMap[open + 1] == close - 1) {
-                    scanner.remove(close);   // outer )
-                    scanner.remove(open);    // outer (
+                    scanner.remove(close);
+                    scanner.remove(open);
                     changed = true;
-                    break;                   // restart with fresh pairMap
+                    break;
                 }
 
-                // 2. Single token inside: (x) → x
-                //    FULL original safety logic restored (this fixes @(x,y) and all your other cases)
+                // 2. Single-token brackets (x) → x   with ALL your original safety checks
                 if (close == open + 2) {
-                    boolean mustKeepBrackets = false;
-
+                    boolean mustKeep = false;
                     if (open > 0) {
                         String prev = scanner.get(open - 1);
                         if (isVariableString(prev) ||
-                            isAtOperator(prev) ||           // ← handles @ operator
-                            FUNCTIONS.contains(prev) ||     // covers Method.isMethodName
+                            isAtOperator(prev) ||
+                            FUNCTIONS.contains(prev) ||      // covers Method.isMethodName
                             isUnaryPreOperator(prev)) {
-                            mustKeepBrackets = true;
+                            mustKeep = true;
                         }
                     }
-                    // if open == 0 → safe to remove (original behaviour)
-
-                    if (!mustKeepBrackets) {
+                    if (!mustKeep) {
                         scanner.remove(close);
                         scanner.remove(open);
                         changed = true;
                         break;
                     }
                 }
 
-                // 3. Empty brackets: () → remove only if not a function / @ / etc.
+                // 3. Empty brackets () → remove only when safe
                 if (close == open + 1) {
-                    boolean mustKeepBrackets = false;
-
+                    boolean mustKeep = false;
                     if (open > 0) {
                         String prev = scanner.get(open - 1);
                         if (isVariableString(prev) ||
                             isAtOperator(prev) ||
                             FUNCTIONS.contains(prev) ||
                             isUnaryPreOperator(prev)) {
-                            mustKeepBrackets = true;
+                            mustKeep = true;
                         }
                     }
-
-                    if (!mustKeepBrackets) {
+                    if (!mustKeep) {
                         scanner.remove(close);
                         scanner.remove(open);
                         changed = true;
                         break;
                     }
                 }
             }
-        } while (changed);   // Repeat until no more changes (handles deep nesting)
-
-        return scanner;
+        } while (changed);   // handles deep nesting like (((x)))
     }
 
-    /**
-     * Builds a map of matching bracket indices.
-     */
     private static int[] buildPairMap(List<String> tokens) {
         int n = tokens.size();
         int[] pairMap = new int[n];
         Arrays.fill(pairMap, -1);
         Deque<Integer> stack = new ArrayDeque<>();
-
         for (int i = 0; i < n; i++) {
             String t = tokens.get(i);
             if ("(".equals(t)) {
@@ -148,17 +137,19 @@ private static int[] buildPairMap(List<String> tokens) {
         }
         return pairMap;
     }
- 
-
-    /**
-     * Test method – run this to verify @(x,y) and all your cases.
-     */
+  
     public static void main(String[] args) {
+         
+        MathExpression mexie = new MathExpression("v=@(x,y)sin(3*log((((4*x-3*y),3)))-4);v(3,2)");
+    
         // Example with @ operator
-        List<String> scanner = new MathExpression("v=@(x,y)sin(3*log((((x-3*y),3)))-4)")
-                .getScanner();
+        List<String> scanner = mexie.getScanner();
 
+        System.out.println("FUNCTIONS:    " + FunctionManager.FUNCTIONS);
         System.out.println("Raw scanner:    " + scanner);
-        System.out.println("Cleaned scanner:" + removeExcessBrackets(scanner));
+        removeExcessBrackets(scanner);
+        System.out.println("Cleaned scanner:" + scanner );
+        System.out.println("Cleaned scanner:" + scanner );
+        System.out.println("eval:" + mexie.solve() );
     }
 }

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

@@ -583,7 +583,6 @@ public void setMathExpression(MathExpression mathExpression) {
         MathExpression oldMe = this.mathExpression;
         try {
             this.mathExpression = mathExpression;
-            System.out.println("expr="+mathExpression.getExpression());
             this.turboExpr = TurboEvaluatorFactory.getCompiler(mathExpression, false).compile();
             this.type = TYPE.ALGEBRAIC_EXPRESSION;
         } catch (Throwable ex) {

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

@@ -1227,6 +1227,32 @@ protected List<String> solve(List<String> list) {
         return Arrays.asList(String.valueOf(GG.evaluate(list)));
     }
 
+    
+    // Automatically strips unbalanced grouping parentheses from captured arguments
+    private static String cleanArgument(String arg) {
+        if (arg == null) return "";
+        arg = arg.trim();
+        int open = 0, close = 0;
+        
+        for (int i = 0; i < arg.length(); i++) {
+            if (arg.charAt(i) == '(') open++;
+            else if (arg.charAt(i) == ')') close++;
+        }
+        
+        // Strip leading redundant '('
+        while (open > close && arg.startsWith("(")) {
+            arg = arg.substring(1).trim();
+            open--;
+        }
+        
+        // Strip trailing redundant ')'
+        while (close > open && arg.endsWith(")")) {
+            arg = arg.substring(0, arg.length() - 1).trim();
+            close--;
+        }
+        
+        return arg;
+    }
     private Token translate(String s, String next) {
         if (s == null || s.isEmpty()) {
             return null;
@@ -1338,7 +1364,7 @@ class FuncArgTracker {
                 continue;
             }
 
-            // ==========================================
+// ==========================================
             // PHASE A: PASSIVE STRING TRACKING
             // ==========================================
             boolean isFuncParen = false;
@@ -1356,20 +1382,23 @@ class FuncArgTracker {
             for (int i = 0; i < trackers.size(); i++) {
                 FuncArgTracker tracker = trackers.get(i);
 
-                // A comma or right paren ONLY belongs to this function if it's at the function's base depth
-                boolean isOwningComma = (t.kind == Token.COMMA && currentParenDepth == tracker.depthLevel);
+                // FIX: A comma belongs to this function if it is the innermost open function
+                // This allows the comma to penetrate redundant grouping parentheses!
+                boolean isOwningComma = (t.kind == Token.COMMA && i == trackers.size() - 1);
+                
+                // The function still closes exactly when its base parenthesis depth resolves
                 boolean isOwningRParen = (t.kind == Token.RPAREN && currentParenDepth == tracker.depthLevel);
 
                 // Prevent the function from capturing its own opening parenthesis
                 boolean isStartingParen = (t.kind == Token.LPAREN && isFuncParen && i == trackers.size() - 1);
 
                 if (isOwningComma) {
-                    // Lock in the finished argument and clear the builder for the next one
-                    tracker.args.add(tracker.currentArg.toString().trim());
+                    // Lock in the finished argument and auto-balance any stripped parens
+                    tracker.args.add(cleanArgument(tracker.currentArg.toString()));
                     tracker.currentArg.setLength(0);
                 } else if (isOwningRParen) {
                     // Function is closing. Lock in the final argument.
-                    String lastArg = tracker.currentArg.toString().trim();
+                    String lastArg = cleanArgument(tracker.currentArg.toString());
                     if (!lastArg.isEmpty() || !tracker.args.isEmpty()) {
                         if (!lastArg.isEmpty()) {
                             tracker.args.add(lastArg);
@@ -1378,7 +1407,7 @@ class FuncArgTracker {
 
                     // Wire up the perfectly parsed arguments directly to the Token
                     tracker.funcToken.rawArgs = tracker.args.toArray(new String[0]);
-                    tracker.funcToken.arity = tracker.args.size(); // Perfect arity counting (handles 0-arg funcs seamlessly)
+                    tracker.funcToken.arity = tracker.args.size(); // Perfect arity counting
 
                 } else if (!isStartingParen) {
                     // It's a regular token inside an argument, just append it!

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

@@ -1383,7 +1383,17 @@ private static void replaceWithFunctionName(List<String> scanner, int start, int
      * @param scanner The list of scanned tokens.
      *
      */
+    
+    
     public static void removeExcessBrackets(List<String> scanner) {
+         BracketCleaner.removeExcessBrackets(scanner);
+    }
+    /**
+     * Old version of {@linkplain MathScanner#removeExcessBrackets(java.util.List) }
+     * @deprecated 
+     * @param scanner 
+     */
+    public static void removeExcessBrackets1(List<String> scanner) {
 
         for (int i = 0; i < scanner.size(); i++) {
 
@@ -1434,7 +1444,6 @@ public static void removeExcessBrackets(List<String> scanner) {
 
             }
         }
-
     }
 
     /**

src/main/java/com/github/gbenroscience/util/Utils.java

@@ -139,6 +139,7 @@ public static void logInfo(String message) {
             Log.i("Kalculitzer", message);
         }
     }
+    
 
     public static boolean isPerfectSquare(int num) {
         if (num < 0) {