Updates to ExprTk

ArashPartow · ArashPartow · commit b18eae763fad · 2018-12-25T14:16:29.000+11:00
diff --git a/exprtk/exprtk.hpp b/exprtk/exprtk.hpp
@@ -13830,7 +13830,7 @@ namespace exprtk
                                                     bfunc_t p2)
          {
             return allocator
-                     .template allocate_type<node_type,T0,T1,bfunc_t&>
+                     .template allocate_type<node_type, T0, T1, bfunc_t&>
                         (p0, p1, p2);
          }
 
@@ -13918,7 +13918,7 @@ namespace exprtk
          static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, bfunc_t p3, bfunc_t p4)
          {
             return allocator
-                      .template allocate_type<node_type,T0,T1,T2,bfunc_t,bfunc_t>
+                      .template allocate_type<node_type, T0, T1, T2, bfunc_t, bfunc_t>
                          (p0, p1, p2, p3, p4);
          }
 
@@ -14015,7 +14015,7 @@ namespace exprtk
                                                     bfunc_t p4, bfunc_t p5, bfunc_t p6)
          {
             return allocator
-                      .template allocate_type<node_type,T0,T1,T2,T3,bfunc_t,bfunc_t>
+                      .template allocate_type<node_type, T0, T1, T2, T3, bfunc_t, bfunc_t>
                          (p0, p1, p2, p3, p4, p5, p6);
          }
 
@@ -14100,7 +14100,7 @@ namespace exprtk
          static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, tfunc_t p3)
          {
             return allocator
-                     .template allocate_type<node_type,T0,T1,T2,tfunc_t>
+                     .template allocate_type<node_type, T0, T1, T2, tfunc_t>
                         (p0, p1, p2, p3);
          }
 
@@ -14191,7 +14191,7 @@ namespace exprtk
          static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2)
          {
             return allocator
-                     .template allocate_type<node_type,T0,T1,T2>
+                     .template allocate_type<node_type, T0, T1, T2>
                         (p0, p1, p2);
          }
 
@@ -14292,7 +14292,7 @@ namespace exprtk
          static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, T3 p3, qfunc_t p4)
          {
             return allocator
-                     .template allocate_type<node_type,T0,T1,T2,T3,qfunc_t>
+                     .template allocate_type<node_type, T0, T1, T2, T3, qfunc_t>
                         (p0, p1, p2, p3, p4);
          }
 
@@ -14375,7 +14375,7 @@ namespace exprtk
          static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, T3 p3)
          {
             return allocator
-                     .template allocate_type<node_type,T0,T1,T2,T3>
+                     .template allocate_type<node_type, T0, T1, T2, T3>
                         (p0, p1, p2, p3);
          }
 
@@ -15501,37 +15501,37 @@ namespace exprtk
          template <typename ResultNode, typename OpType, typename ExprNode>
          inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[1])
          {
-            return allocate<ResultNode>(operation,branch[0]);
+            return allocate<ResultNode>(operation, branch[0]);
          }
 
          template <typename ResultNode, typename OpType, typename ExprNode>
          inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[2])
          {
-            return allocate<ResultNode>(operation,branch[0],branch[1]);
+            return allocate<ResultNode>(operation, branch[0], branch[1]);
          }
 
          template <typename ResultNode, typename OpType, typename ExprNode>
          inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[3])
          {
-            return allocate<ResultNode>(operation,branch[0],branch[1],branch[2]);
+            return allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);
          }
 
          template <typename ResultNode, typename OpType, typename ExprNode>
          inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[4])
          {
-            return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3]);
+            return allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);
          }
 
          template <typename ResultNode, typename OpType, typename ExprNode>
          inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[5])
          {
-            return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4]);
+            return allocate<ResultNode>(operation, branch[0],branch[1], branch[2], branch[3], branch[4]);
          }
 
          template <typename ResultNode, typename OpType, typename ExprNode>
          inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[6])
          {
-            return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4],branch[5]);
+            return allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3], branch[4], branch[5]);
          }
 
          template <typename node_type>
@@ -16094,20 +16094,20 @@ namespace exprtk
 
       typedef T (*ff00_functor)();
       typedef T (*ff01_functor)(T);
-      typedef T (*ff02_functor)(T,T);
-      typedef T (*ff03_functor)(T,T,T);
-      typedef T (*ff04_functor)(T,T,T,T);
-      typedef T (*ff05_functor)(T,T,T,T,T);
-      typedef T (*ff06_functor)(T,T,T,T,T,T);
-      typedef T (*ff07_functor)(T,T,T,T,T,T,T);
-      typedef T (*ff08_functor)(T,T,T,T,T,T,T,T);
-      typedef T (*ff09_functor)(T,T,T,T,T,T,T,T,T);
-      typedef T (*ff10_functor)(T,T,T,T,T,T,T,T,T,T);
-      typedef T (*ff11_functor)(T,T,T,T,T,T,T,T,T,T,T);
-      typedef T (*ff12_functor)(T,T,T,T,T,T,T,T,T,T,T,T);
-      typedef T (*ff13_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T);
-      typedef T (*ff14_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T);
-      typedef T (*ff15_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T);
+      typedef T (*ff02_functor)(T, T);
+      typedef T (*ff03_functor)(T, T, T);
+      typedef T (*ff04_functor)(T, T, T, T);
+      typedef T (*ff05_functor)(T, T, T, T, T);
+      typedef T (*ff06_functor)(T, T, T, T, T, T);
+      typedef T (*ff07_functor)(T, T, T, T, T, T, T);
+      typedef T (*ff08_functor)(T, T, T, T, T, T, T, T);
+      typedef T (*ff09_functor)(T, T, T, T, T, T, T, T, T);
+      typedef T (*ff10_functor)(T, T, T, T, T, T, T, T, T, T);
+      typedef T (*ff11_functor)(T, T, T, T, T, T, T, T, T, T, T);
+      typedef T (*ff12_functor)(T, T, T, T, T, T, T, T, T, T, T, T);
+      typedef T (*ff13_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T);
+      typedef T (*ff14_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T, T);
+      typedef T (*ff15_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T);
 
    protected:
 
@@ -36950,11 +36950,9 @@ namespace exprtk
 
       inline T operator() (const std::size_t& ps_index, parameter_list_t parameters)
       {
-         std::string file_name;
+         std::string file_name = to_str(string_t(parameters[0]));
          std::string access;
 
-         file_name = to_str(string_t(parameters[0]));
-
          if (file_name.empty())
             return T(0);
 
@@ -37035,27 +37033,27 @@ namespace exprtk
             case 0  : {
                          const string_t buffer(parameters[1]);
                          amount = buffer.size();
-                         return T(fd->write(buffer,amount) ? 1 : 0);
+                         return T(fd->write(buffer, amount) ? 1 : 0);
                       }
 
             case 1  : {
                          const string_t buffer(parameters[1]);
                          amount = std::min(buffer.size(),
                                            static_cast<std::size_t>(scalar_t(parameters[2])()));
-                         return T(fd->write(buffer,amount) ? 1 : 0);
+                         return T(fd->write(buffer, amount) ? 1 : 0);
                       }
 
             case 2  : {
                          const vector_t vec(parameters[1]);
                          amount = vec.size();
-                         return T(fd->write(vec,amount) ? 1 : 0);
+                         return T(fd->write(vec, amount) ? 1 : 0);
                       }
 
             case 3  : {
                          const vector_t vec(parameters[1]);
                          amount = std::min(vec.size(),
                                            static_cast<std::size_t>(scalar_t(parameters[2])()));
-                         return T(fd->write(vec,amount) ? 1 : 0);
+                         return T(fd->write(vec, amount) ? 1 : 0);
                       }
          }
 
@@ -37256,10 +37254,10 @@ namespace exprtk
    namespace details
    {
       template <typename T>
-      inline void kahan_sum(T& sum, T& error, T v)
+      inline void kahan_sum(T& sum, T& error, const T v)
       {
-         T x = v - error;
-         T y = sum + x;
+         const T x = v - error;
+         const T y = sum + x;
          error = (y - sum) - x;
          sum = y;
       }
@@ -37983,7 +37981,7 @@ namespace exprtk
          else if (helper::invalid_range(y, r0, r1))
             return std::numeric_limits<T>::quiet_NaN();
 
-         T a = scalar_t(parameters[0])();
+         const T a = scalar_t(parameters[0])();
 
          for (std::size_t i = r0; i <= r1; ++i)
          {
@@ -38081,7 +38079,7 @@ namespace exprtk
          else if (helper::invalid_range(z, r0, r1))
             return std::numeric_limits<T>::quiet_NaN();
 
-         T a = scalar_t(parameters[0])();
+         const T a = scalar_t(parameters[0])();
 
          for (std::size_t i = r0; i <= r1; ++i)
          {

Original file line number	Diff line number	Diff line change
`@@ -13830,7 +13830,7 @@ namespace exprtk`
`13830`	`13830`	`bfunc_t p2)`
`13831`	`13831`	`{`
`13832`	`13832`	`return allocator`
`13833`		`- .template allocate_type<node_type,T0,T1,bfunc_t&>`
	`13833`	`+ .template allocate_type<node_type, T0, T1, bfunc_t&>`
`13834`	`13834`	`(p0, p1, p2);`
`13835`	`13835`	`}`
`13836`	`13836`
`@@ -13918,7 +13918,7 @@ namespace exprtk`
`13918`	`13918`	`static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, bfunc_t p3, bfunc_t p4)`
`13919`	`13919`	`{`
`13920`	`13920`	`return allocator`
`13921`		`- .template allocate_type<node_type,T0,T1,T2,bfunc_t,bfunc_t>`
	`13921`	`+ .template allocate_type<node_type, T0, T1, T2, bfunc_t, bfunc_t>`
`13922`	`13922`	`(p0, p1, p2, p3, p4);`
`13923`	`13923`	`}`
`13924`	`13924`
`@@ -14015,7 +14015,7 @@ namespace exprtk`
`14015`	`14015`	`bfunc_t p4, bfunc_t p5, bfunc_t p6)`
`14016`	`14016`	`{`
`14017`	`14017`	`return allocator`
`14018`		`- .template allocate_type<node_type,T0,T1,T2,T3,bfunc_t,bfunc_t>`
	`14018`	`+ .template allocate_type<node_type, T0, T1, T2, T3, bfunc_t, bfunc_t>`
`14019`	`14019`	`(p0, p1, p2, p3, p4, p5, p6);`
`14020`	`14020`	`}`
`14021`	`14021`
`@@ -14100,7 +14100,7 @@ namespace exprtk`
`14100`	`14100`	`static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, tfunc_t p3)`
`14101`	`14101`	`{`
`14102`	`14102`	`return allocator`
`14103`		`- .template allocate_type<node_type,T0,T1,T2,tfunc_t>`
	`14103`	`+ .template allocate_type<node_type, T0, T1, T2, tfunc_t>`
`14104`	`14104`	`(p0, p1, p2, p3);`
`14105`	`14105`	`}`
`14106`	`14106`
`@@ -14191,7 +14191,7 @@ namespace exprtk`
`14191`	`14191`	`static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2)`
`14192`	`14192`	`{`
`14193`	`14193`	`return allocator`
`14194`		`- .template allocate_type<node_type,T0,T1,T2>`
	`14194`	`+ .template allocate_type<node_type, T0, T1, T2>`
`14195`	`14195`	`(p0, p1, p2);`
`14196`	`14196`	`}`
`14197`	`14197`
`@@ -14292,7 +14292,7 @@ namespace exprtk`
`14292`	`14292`	`static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, T3 p3, qfunc_t p4)`
`14293`	`14293`	`{`
`14294`	`14294`	`return allocator`
`14295`		`- .template allocate_type<node_type,T0,T1,T2,T3,qfunc_t>`
	`14295`	`+ .template allocate_type<node_type, T0, T1, T2, T3, qfunc_t>`
`14296`	`14296`	`(p0, p1, p2, p3, p4);`
`14297`	`14297`	`}`
`14298`	`14298`
`@@ -14375,7 +14375,7 @@ namespace exprtk`
`14375`	`14375`	`static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, T3 p3)`
`14376`	`14376`	`{`
`14377`	`14377`	`return allocator`
`14378`		`- .template allocate_type<node_type,T0,T1,T2,T3>`
	`14378`	`+ .template allocate_type<node_type, T0, T1, T2, T3>`
`14379`	`14379`	`(p0, p1, p2, p3);`
`14380`	`14380`	`}`
`14381`	`14381`
`@@ -15501,37 +15501,37 @@ namespace exprtk`
`15501`	`15501`	`template <typename ResultNode, typename OpType, typename ExprNode>`
`15502`	`15502`	`inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[1])`
`15503`	`15503`	`{`
`15504`		`- return allocate<ResultNode>(operation,branch[0]);`
	`15504`	`+ return allocate<ResultNode>(operation, branch[0]);`
`15505`	`15505`	`}`
`15506`	`15506`
`15507`	`15507`	`template <typename ResultNode, typename OpType, typename ExprNode>`
`15508`	`15508`	`inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[2])`
`15509`	`15509`	`{`
`15510`		`- return allocate<ResultNode>(operation,branch[0],branch[1]);`
	`15510`	`+ return allocate<ResultNode>(operation, branch[0], branch[1]);`
`15511`	`15511`	`}`
`15512`	`15512`
`15513`	`15513`	`template <typename ResultNode, typename OpType, typename ExprNode>`
`15514`	`15514`	`inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[3])`
`15515`	`15515`	`{`
`15516`		`- return allocate<ResultNode>(operation,branch[0],branch[1],branch[2]);`
	`15516`	`+ return allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);`
`15517`	`15517`	`}`
`15518`	`15518`
`15519`	`15519`	`template <typename ResultNode, typename OpType, typename ExprNode>`
`15520`	`15520`	`inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[4])`
`15521`	`15521`	`{`
`15522`		`- return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3]);`
	`15522`	`+ return allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);`
`15523`	`15523`	`}`
`15524`	`15524`
`15525`	`15525`	`template <typename ResultNode, typename OpType, typename ExprNode>`
`15526`	`15526`	`inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[5])`
`15527`	`15527`	`{`
`15528`		`- return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4]);`
	`15528`	`+ return allocate<ResultNode>(operation, branch[0],branch[1], branch[2], branch[3], branch[4]);`
`15529`	`15529`	`}`
`15530`	`15530`
`15531`	`15531`	`template <typename ResultNode, typename OpType, typename ExprNode>`
`15532`	`15532`	`inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[6])`
`15533`	`15533`	`{`
`15534`		`- return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4],branch[5]);`
	`15534`	`+ return allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3], branch[4], branch[5]);`
`15535`	`15535`	`}`
`15536`	`15536`
`15537`	`15537`	`template <typename node_type>`
`@@ -16094,20 +16094,20 @@ namespace exprtk`
`16094`	`16094`
`16095`	`16095`	`typedef T (*ff00_functor)();`
`16096`	`16096`	`typedef T (*ff01_functor)(T);`
`16097`		`- typedef T (*ff02_functor)(T,T);`
`16098`		`- typedef T (*ff03_functor)(T,T,T);`
`16099`		`- typedef T (*ff04_functor)(T,T,T,T);`
`16100`		`- typedef T (*ff05_functor)(T,T,T,T,T);`
`16101`		`- typedef T (*ff06_functor)(T,T,T,T,T,T);`
`16102`		`- typedef T (*ff07_functor)(T,T,T,T,T,T,T);`
`16103`		`- typedef T (*ff08_functor)(T,T,T,T,T,T,T,T);`
`16104`		`- typedef T (*ff09_functor)(T,T,T,T,T,T,T,T,T);`
`16105`		`- typedef T (*ff10_functor)(T,T,T,T,T,T,T,T,T,T);`
`16106`		`- typedef T (*ff11_functor)(T,T,T,T,T,T,T,T,T,T,T);`
`16107`		`- typedef T (*ff12_functor)(T,T,T,T,T,T,T,T,T,T,T,T);`
`16108`		`- typedef T (*ff13_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T);`
`16109`		`- typedef T (*ff14_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T);`
`16110`		`- typedef T (*ff15_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T);`
	`16097`	`+ typedef T (*ff02_functor)(T, T);`
	`16098`	`+ typedef T (*ff03_functor)(T, T, T);`
	`16099`	`+ typedef T (*ff04_functor)(T, T, T, T);`
	`16100`	`+ typedef T (*ff05_functor)(T, T, T, T, T);`
	`16101`	`+ typedef T (*ff06_functor)(T, T, T, T, T, T);`
	`16102`	`+ typedef T (*ff07_functor)(T, T, T, T, T, T, T);`
	`16103`	`+ typedef T (*ff08_functor)(T, T, T, T, T, T, T, T);`
	`16104`	`+ typedef T (*ff09_functor)(T, T, T, T, T, T, T, T, T);`
	`16105`	`+ typedef T (*ff10_functor)(T, T, T, T, T, T, T, T, T, T);`
	`16106`	`+ typedef T (*ff11_functor)(T, T, T, T, T, T, T, T, T, T, T);`
	`16107`	`+ typedef T (*ff12_functor)(T, T, T, T, T, T, T, T, T, T, T, T);`
	`16108`	`+ typedef T (*ff13_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T);`
	`16109`	`+ typedef T (*ff14_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T, T);`
	`16110`	`+ typedef T (*ff15_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T);`
`16111`	`16111`
`16112`	`16112`	`protected:`
`16113`	`16113`
`@@ -36950,11 +36950,9 @@ namespace exprtk`
`36950`	`36950`
`36951`	`36951`	`inline T operator() (const std::size_t& ps_index, parameter_list_t parameters)`
`36952`	`36952`	`{`
`36953`		`- std::string file_name;`
	`36953`	`+ std::string file_name = to_str(string_t(parameters[0]));`
`36954`	`36954`	`std::string access;`
`36955`	`36955`
`36956`		`- file_name = to_str(string_t(parameters[0]));`
`36957`		`-`
`36958`	`36956`	`if (file_name.empty())`
`36959`	`36957`	`return T(0);`
`36960`	`36958`
`@@ -37035,27 +37033,27 @@ namespace exprtk`
`37035`	`37033`	`case 0 : {`
`37036`	`37034`	`const string_t buffer(parameters[1]);`
`37037`	`37035`	`amount = buffer.size();`
`37038`		`- return T(fd->write(buffer,amount) ? 1 : 0);`
	`37036`	`+ return T(fd->write(buffer, amount) ? 1 : 0);`
`37039`	`37037`	`}`
`37040`	`37038`
`37041`	`37039`	`case 1 : {`
`37042`	`37040`	`const string_t buffer(parameters[1]);`
`37043`	`37041`	`amount = std::min(buffer.size(),`
`37044`	`37042`	`static_cast<std::size_t>(scalar_t(parameters[2])()));`
`37045`		`- return T(fd->write(buffer,amount) ? 1 : 0);`
	`37043`	`+ return T(fd->write(buffer, amount) ? 1 : 0);`
`37046`	`37044`	`}`
`37047`	`37045`
`37048`	`37046`	`case 2 : {`
`37049`	`37047`	`const vector_t vec(parameters[1]);`
`37050`	`37048`	`amount = vec.size();`
`37051`		`- return T(fd->write(vec,amount) ? 1 : 0);`
	`37049`	`+ return T(fd->write(vec, amount) ? 1 : 0);`
`37052`	`37050`	`}`
`37053`	`37051`
`37054`	`37052`	`case 3 : {`
`37055`	`37053`	`const vector_t vec(parameters[1]);`
`37056`	`37054`	`amount = std::min(vec.size(),`
`37057`	`37055`	`static_cast<std::size_t>(scalar_t(parameters[2])()));`
`37058`		`- return T(fd->write(vec,amount) ? 1 : 0);`
	`37056`	`+ return T(fd->write(vec, amount) ? 1 : 0);`
`37059`	`37057`	`}`
`37060`	`37058`	`}`
`37061`	`37059`
`@@ -37256,10 +37254,10 @@ namespace exprtk`
`37256`	`37254`	`namespace details`
`37257`	`37255`	`{`
`37258`	`37256`	`template <typename T>`
`37259`		`- inline void kahan_sum(T& sum, T& error, T v)`
	`37257`	`+ inline void kahan_sum(T& sum, T& error, const T v)`
`37260`	`37258`	`{`
`37261`		`- T x = v - error;`
`37262`		`- T y = sum + x;`
	`37259`	`+ const T x = v - error;`
	`37260`	`+ const T y = sum + x;`
`37263`	`37261`	`error = (y - sum) - x;`
`37264`	`37262`	`sum = y;`
`37265`	`37263`	`}`
`@@ -37983,7 +37981,7 @@ namespace exprtk`
`37983`	`37981`	`else if (helper::invalid_range(y, r0, r1))`
`37984`	`37982`	`return std::numeric_limits<T>::quiet_NaN();`
`37985`	`37983`
`37986`		`- T a = scalar_t(parameters[0])();`
	`37984`	`+ const T a = scalar_t(parameters[0])();`
`37987`	`37985`
`37988`	`37986`	`for (std::size_t i = r0; i <= r1; ++i)`
`37989`	`37987`	`{`
`@@ -38081,7 +38079,7 @@ namespace exprtk`
`38081`	`38079`	`else if (helper::invalid_range(z, r0, r1))`
`38082`	`38080`	`return std::numeric_limits<T>::quiet_NaN();`
`38083`	`38081`
`38084`		`- T a = scalar_t(parameters[0])();`
	`38082`	`+ const T a = scalar_t(parameters[0])();`
`38085`	`38083`
`38086`	`38084`	`for (std::size_t i = r0; i <= r1; ++i)`
`38087`	`38085`	`{`