Parser: minor optimization

  - x**y where y is 0.5 -> sqrt(x)

  - pow(pow(x,y),z) -> pow(x,y*z)

Sync with AMReX-Codes/amrex#4444.

Author: WeiqunZhang

Src/amrexpr_Parser_Exe.cpp

@@ -35,6 +35,11 @@ parser_compile_exe_size (struct parser_node* node, char*& p, std::size_t& exe_si
     // In parser_exe_eval, we push to the stack for NUMBER, SYMBOL, VP, PP.
     // In parser_exe_eval, we pop the stack for ADD, SUB, MUL, DIV, F2, and IF.
 
+    // Note that for + and * the nodes have been sorted before this function
+    // is called. So we don't need to worry about cases like f(x) + x.
+
+    // Note that there is no PARSER_SUB. a-b is actually a+(-b).
+
     switch (node->type)
     {
     case PARSER_NUMBER:
@@ -474,6 +479,19 @@ parser_compile_exe_size (struct parser_node* node, char*& p, std::size_t& exe_si
             }
             exe_size += sizeof(ParserExePOWI);
         }
+        else if (((struct parser_f2*)node)->ftype == PARSER_POW &&
+                 ((struct parser_f2*)node)->r->type == PARSER_NUMBER &&
+                 parser_get_number(((struct parser_f2*)node)->r) == 0.5)
+        {
+            parser_compile_exe_size(((struct parser_f2*)node)->l, p, exe_size,
+                                    max_stack_size, stack_size, local_variables);
+            if (p) {
+                auto *t = new(p) ParserExeF1;
+                p      += sizeof(ParserExeF1);
+                t->ftype = PARSER_SQRT;
+            }
+            exe_size += sizeof(ParserExeF1);
+        }
         else
         {
             int d1 = parser_ast_depth(((struct parser_f2*)node)->l);

Src/amrexpr_Parser_Y.cpp

@@ -1307,6 +1307,16 @@ parser_ast_optimize (struct parser_node* node, std::map<std::string,double>& loc
             node->type = PARSER_DIV;
             parser_set_number(node->l, 1.0);
         }
+        else if (((struct parser_f2*)node)->ftype == PARSER_POW &&
+                 ((struct parser_f2*)node)->l->type == PARSER_F2 &&
+                 ((struct parser_f2*)((struct parser_f2*)node)->l)->ftype == PARSER_POW)
+        { // pow(pow(,),)
+            std::swap(node->l, node->r);
+            std::swap(node->l, node->r->l);
+            node->r->type = PARSER_MUL;
+            parser_ast_sort(node);
+            parser_ast_optimize(node, local_consts);
+        }
         break;
     case PARSER_F3:
         parser_ast_optimize(((struct parser_f3*)node)->n1, local_consts);

Tests/Parser2/fn.cpp

@@ -206,6 +206,18 @@ double f (int icase, double x, double y, double z)
         return pow(x,y+1);
     case 97:
         return pow(x+1,y);
+    case 98:
+        return pow(x,0.5);
+    case 99:
+        return pow(pow(x,y),z);
+    case 100:
+        return (x+y+z) + (x-y-z);
+    case 101:
+        return (x+y+z) - (-x+y-z);
+    case 102:
+        return x/y/z*x*y*z;
+    case 103:
+        return ((x+y*z-x*y/z-x*y*z-x/y*z-x/y+z*x/y/z*x*y+z*x-y*z));
     default:
         throw std::runtime_error("Unknown case "+std::to_string(icase));
         return 0.0;