From 187456164ef40e5b864d52e1c389012819d40211 Mon Sep 17 00:00:00 2001
From: Arash Partow <partow@gmail.com>
Date: Wed, 2 Dec 2015 19:30:27 +1100
Subject: [PATCH] C++ Mathematical Expression Library (ExprTk) 
 http://www.partow.net/programming/exprtk/index.html

---
 exprtk.hpp      | 328 ++++++++++++++++++++++++++++++++++--------------
 exprtk_test.cpp |  36 +++---
 readme.txt      |  56 ++++-----
 3 files changed, 283 insertions(+), 137 deletions(-)

diff --git a/exprtk.hpp b/exprtk.hpp
index 544cf81..5726160 100644
--- a/exprtk.hpp
+++ b/exprtk.hpp
@@ -57,7 +57,7 @@
 
 namespace exprtk
 {
-   #if exprtk_enable_debugging
+   #ifdef exprtk_enable_debugging
      #define exprtk_debug(params) printf params
    #else
      #define exprtk_debug(params) (void)0
@@ -678,16 +678,16 @@ namespace exprtk
       {
          namespace constant
          {
-            static const double e       =  2.718281828459045235360;
-            static const double pi      =  3.141592653589793238462;
-            static const double pi_2    =  1.570796326794896619231;
-            static const double pi_4    =  0.785398163397448309616;
-            static const double pi_180  =  0.017453292519943295769;
-            static const double _1_pi   =  0.318309886183790671538;
-            static const double _2_pi   =  0.636619772367581343076;
-            static const double _180_pi = 57.295779513082320876798;
-            static const double log2    =  0.693147180559945309417;
-            static const double sqrt2   =  1.414213562373095048801;
+            static const double e       =  2.71828182845904523536028747135266249775724709369996;
+            static const double pi      =  3.14159265358979323846264338327950288419716939937510;
+            static const double pi_2    =  1.57079632679489661923132169163975144209858469968755;
+            static const double pi_4    =  0.78539816339744830961566084581987572104929234984378;
+            static const double pi_180  =  0.01745329251994329576923690768488612713442871888542;
+            static const double _1_pi   =  0.31830988618379067153776752674502872406891929148091;
+            static const double _2_pi   =  0.63661977236758134307553505349005744813783858296183;
+            static const double _180_pi = 57.29577951308232087679815481410517033240547246656443;
+            static const double log2    =  0.69314718055994530941723212145817656807550013436026;
+            static const double sqrt2   =  1.41421356237309504880168872420969807856967187537695;
          }
 
          namespace details
@@ -1760,7 +1760,7 @@ namespace exprtk
                if (curr != itr)
                {
                   instate = true;
-                  d += compute_pow10(tmp_d,-std::distance(curr,itr));
+                  d += compute_pow10(tmp_d,static_cast<int>(-std::distance(curr,itr)));
                }
 
                #undef parse_digit_1
@@ -6733,9 +6733,9 @@ namespace exprtk
       std::string stringvar_node<T>::null_value = std::string("");
 
       template <typename T>
-      class string_range_node :  public expression_node <T>,
-                                 public string_base_node<T>,
-                                 public range_interface <T>
+      class string_range_node : public expression_node <T>,
+                                public string_base_node<T>,
+                                public range_interface <T>
       {
       public:
 
@@ -11600,7 +11600,7 @@ namespace exprtk
       public:
 
          virtual ~boc_base_node()
-       {}
+         {}
 
          inline virtual operator_type operation() const
          {
@@ -13554,6 +13554,43 @@ namespace exprtk
          const T& v_;
       };
 
+      template <typename T, typename PowOp>
+      class bipow_node : public expression_node<T>
+      {
+      public:
+
+         typedef expression_node<T>* expression_ptr;
+         typedef std::pair<expression_ptr, bool> branch_t;
+         typedef PowOp operation_t;
+
+         explicit bipow_node(expression_ptr brnch)
+         {
+            init_branches<1>(branch_, brnch);
+         }
+
+         ~bipow_node()
+         {
+            cleanup_branches::execute<T,1>(branch_);
+         }
+
+         inline T value() const
+         {
+            return PowOp::result(branch_[0].first->value());
+         }
+
+         inline typename expression_node<T>::node_type type() const
+         {
+            return expression_node<T>::e_ipow;
+         }
+
+      private:
+
+         bipow_node(const bipow_node<T,PowOp>&);
+         bipow_node<T,PowOp>& operator=(const bipow_node<T,PowOp>&);
+
+         branch_t branch_[1];
+      };
+
       template <typename T, typename PowOp>
       class ipowinv_node : public expression_node<T>
       {
@@ -13584,6 +13621,43 @@ namespace exprtk
          const T& v_;
       };
 
+      template <typename T, typename PowOp>
+      class bipowninv_node : public expression_node<T>
+      {
+      public:
+
+         typedef expression_node<T>* expression_ptr;
+         typedef std::pair<expression_ptr, bool> branch_t;
+         typedef PowOp operation_t;
+
+         explicit bipowninv_node(expression_ptr brnch)
+         {
+            init_branches<1>(branch_, brnch);
+         }
+
+         ~bipowninv_node()
+         {
+            cleanup_branches::execute<T,1>(branch_);
+         }
+
+         inline T value() const
+         {
+            return (T(1) / PowOp::result(branch_[0].first->value()));
+         }
+
+         inline typename expression_node<T>::node_type type() const
+         {
+            return expression_node<T>::e_ipowinv;
+         }
+
+      private:
+
+         bipowninv_node(const bipowninv_node<T,PowOp>&);
+         bipowninv_node<T,PowOp>& operator=(const bipowninv_node<T,PowOp>&);
+
+         branch_t branch_[1];
+      };
+
       template <typename T>
       inline bool is_vov_node(const expression_node<T>* node)
       {
@@ -17139,7 +17213,7 @@ namespace exprtk
          {
             st = e_usr_variable_type;
             default_value = T(0);
-            error_message = "";
+            error_message.clear();
 
             return true;
          }
@@ -17698,7 +17772,7 @@ namespace exprtk
          settings_store& disable_inequality_operation(settings_inequality_opr inequality)
          {
             if (
-                 (e_assign_unknown != inequality) &&
+                 (e_ineq_unknown != inequality) &&
                  (static_cast<std::size_t>(inequality) < details::inequality_ops_list_size)
                )
             {
@@ -20039,7 +20113,7 @@ namespace exprtk
                return error_node();
             }
 
-            // Can we optimize away the case statement?
+            // Can we optimise away the case statement?
             if (is_constant_node(condition) && is_false(condition))
             {
                free_node(node_allocator_, condition);
@@ -20183,7 +20257,7 @@ namespace exprtk
                return error_node();
             }
 
-            // Can we optimize away the case statement?
+            // Can we optimise away the case statement?
             if (is_constant_node(condition) && is_false(condition))
             {
                free_node(node_allocator_, condition);
@@ -23259,7 +23333,7 @@ namespace exprtk
          }
          #endif
 
-         inline bool unary_optimizable(const details::operator_type& operation) const
+         inline bool unary_optimisable(const details::operator_type& operation) const
          {
             return (details::e_abs   == operation) || (details::e_acos  == operation) ||
                    (details::e_acosh == operation) || (details::e_asin  == operation) ||
@@ -23283,7 +23357,7 @@ namespace exprtk
                    (details::e_frac  == operation) || (details::e_trunc == operation);
          }
 
-         inline bool sf3_optimizable(const std::string& sf3id, trinary_functor_t& tfunc)
+         inline bool sf3_optimisable(const std::string& sf3id, trinary_functor_t& tfunc)
          {
             typename sf3_map_t::iterator itr = sf3_map_->find(sf3id);
 
@@ -23295,7 +23369,7 @@ namespace exprtk
             return true;
          }
 
-         inline bool sf4_optimizable(const std::string& sf4id, quaternary_functor_t& qfunc)
+         inline bool sf4_optimisable(const std::string& sf4id, quaternary_functor_t& qfunc)
          {
             typename sf4_map_t::iterator itr = sf4_map_->find(sf4id);
 
@@ -23307,7 +23381,7 @@ namespace exprtk
             return true;
          }
 
-         inline bool sf3_optimizable(const std::string& sf3id, details::operator_type& operation)
+         inline bool sf3_optimisable(const std::string& sf3id, details::operator_type& operation)
          {
             typename sf3_map_t::iterator itr = sf3_map_->find(sf3id);
 
@@ -23319,7 +23393,7 @@ namespace exprtk
             return true;
          }
 
-         inline bool sf4_optimizable(const std::string& sf4id, details::operator_type& operation)
+         inline bool sf4_optimisable(const std::string& sf4id, details::operator_type& operation)
          {
             typename sf4_map_t::iterator itr = sf4_map_->find(sf4id);
 
@@ -23343,9 +23417,9 @@ namespace exprtk
                return error_node();
             else if (details::is_constant_node(branch[0]))
                return synthesize_expression<unary_node_t,1>(operation,branch);
-            else if (unary_optimizable(operation) && details::is_variable_node(branch[0]))
+            else if (unary_optimisable(operation) && details::is_variable_node(branch[0]))
                return synthesize_uv_expression(operation,branch);
-            else if (unary_optimizable(operation) && details::is_ivector_node(branch[0]))
+            else if (unary_optimisable(operation) && details::is_ivector_node(branch[0]))
                return synthesize_uvec_expression(operation,branch);
             else
                return synthesize_unary_expression(operation,branch);
@@ -23413,7 +23487,7 @@ namespace exprtk
             }
          }
 
-         inline bool operation_optimizable(const details::operator_type& operation) const
+         inline bool operation_optimisable(const details::operator_type& operation) const
          {
             return (details::e_add  == operation) ||
                    (details::e_sub  == operation) ||
@@ -23481,47 +23555,47 @@ namespace exprtk
             return branch_to_id(branch[0]) + std::string("o") + branch_to_id(branch[1]);
          }
 
-         inline bool cov_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool cov_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (details::is_constant_node(branch[0]) && details::is_variable_node(branch[1]));
          }
 
-         inline bool voc_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool voc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (details::is_variable_node(branch[0]) && details::is_constant_node(branch[1]));
          }
 
-         inline bool vov_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool vov_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (details::is_variable_node(branch[0]) && details::is_variable_node(branch[1]));
          }
 
-         inline bool cob_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool cob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (details::is_constant_node(branch[0]) && !details::is_constant_node(branch[1]));
          }
 
-         inline bool boc_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool boc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (!details::is_constant_node(branch[0]) && details::is_constant_node(branch[1]));
          }
 
-         inline bool cocob_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool cocob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
             if (
                  (details::e_add == operation) ||
@@ -23537,7 +23611,7 @@ namespace exprtk
                return false;
          }
 
-         inline bool coboc_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool coboc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
             if (
                  (details::e_add == operation) ||
@@ -23553,33 +23627,33 @@ namespace exprtk
                return false;
          }
 
-         inline bool uvouv_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool uvouv_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (details::is_uv_node(branch[0]) && details::is_uv_node(branch[1]));
          }
 
-         inline bool vob_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool vob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (details::is_variable_node(branch[0]) && !details::is_variable_node(branch[1]));
          }
 
-         inline bool bov_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool bov_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (!details::is_variable_node(branch[0]) && details::is_variable_node(branch[1]));
          }
 
-         inline bool binext_optimizable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
+         inline bool binext_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
          {
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
             else
                return (!details::is_constant_node(branch[0]) || !details::is_constant_node(branch[1]));
@@ -23605,6 +23679,22 @@ namespace exprtk
                return false;
          }
 
+         inline bool is_constpow_operation(const details::operator_type& operation, expression_node_ptr(&branch)[2])
+         {
+            if (
+                 !is_constant_node(branch[1]) ||
+                  is_constant_node(branch[0]) ||
+                  is_variable_node(branch[0]) ||
+                  is_vector_node  (branch[0]) ||
+                  is_generally_string_node(branch[0])
+               )
+               return false;
+
+            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
+
+            return cardinal_pow_optimisable(operation, c);
+         }
+
          inline bool is_invalid_break_continue_op(expression_node_ptr (&branch)[2])
          {
             return (
@@ -23750,7 +23840,11 @@ namespace exprtk
             else if (is_string_operation(operation,branch))
                return synthesize_string_expression(operation,branch);
             else if (is_null_present(branch))
-               return synthesize_null_expression(operation,branch);
+               return synthesize_null_expression(operation, branch);
+            #ifndef exprtk_disable_cardinal_pow_optimisation
+            else if (is_constpow_operation(operation, branch))
+               return cardinal_pow_optimisation(branch);
+            #endif
 
             expression_node_ptr result = error_node();
 
@@ -23770,30 +23864,30 @@ namespace exprtk
                */
                result = error_node();
 
-               if (cocob_optimizable(operation,branch))
+               if (cocob_optimisable(operation,branch))
                   result = synthesize_cocob_expression::process(*this,operation,branch);
-               else if (coboc_optimizable(operation,branch) && (0 == result))
+               else if (coboc_optimisable(operation,branch) && (0 == result))
                   result = synthesize_coboc_expression::process(*this,operation,branch);
 
                if (result)
                   return result;
             }
 
-            if (uvouv_optimizable(operation,branch))
+            if (uvouv_optimisable(operation,branch))
                return synthesize_uvouv_expression(operation,branch);
-            else if (vob_optimizable(operation,branch))
+            else if (vob_optimisable(operation,branch))
                return synthesize_vob_expression::process(*this,operation,branch);
-            else if (bov_optimizable(operation,branch))
+            else if (bov_optimisable(operation,branch))
                return synthesize_bov_expression::process(*this,operation,branch);
-            else if (cob_optimizable(operation,branch))
+            else if (cob_optimisable(operation,branch))
                return synthesize_cob_expression::process(*this,operation,branch);
-            else if (boc_optimizable(operation,branch))
+            else if (boc_optimisable(operation,branch))
                return synthesize_boc_expression::process(*this,operation,branch);
             #ifndef exprtk_disable_enhanced_features
-            else if (cov_optimizable(operation,branch))
+            else if (cov_optimisable(operation,branch))
                return synthesize_cov_expression::process(*this,operation,branch);
             #endif
-            else if (binext_optimizable(operation,branch))
+            else if (binext_optimisable(operation,branch))
                return synthesize_binary_ext_expression::process(*this,operation,branch);
             else
                return synthesize_expression<binary_node_t,2>(operation,branch);
@@ -23853,7 +23947,7 @@ namespace exprtk
 
                return error_node();
             }
-            // Can the condition be immediately evaluated? if so optimize.
+            // Can the condition be immediately evaluated? if so optimise.
             else if (details::is_constant_node(condition))
             {
                // True branch
@@ -23899,7 +23993,7 @@ namespace exprtk
 
                return error_node();
             }
-            // Can the condition be immediately evaluated? if so optimize.
+            // Can the condition be immediately evaluated? if so optimise.
             else if (details::is_constant_node(condition))
             {
                // True branch
@@ -23930,9 +24024,9 @@ namespace exprtk
                return error_node();
          }
          #else
-         inline expression_node_ptr conditional_string(expression_node_ptr ,
-                                                       expression_node_ptr ,
-                                                       expression_node_ptr ) const
+         inline expression_node_ptr conditional_string(expression_node_ptr,
+                                                       expression_node_ptr,
+                                                       expression_node_ptr) const
          {
             return error_node();
          }
@@ -24055,7 +24149,7 @@ namespace exprtk
 
          template <typename Allocator,
                    template <typename,typename> class Sequence>
-         inline expression_node_ptr const_optimize_switch(Sequence<expression_node_ptr,Allocator>& arg_list)
+         inline expression_node_ptr const_optimise_switch(Sequence<expression_node_ptr,Allocator>& arg_list)
          {
             expression_node_ptr result = error_node();
 
@@ -24091,7 +24185,7 @@ namespace exprtk
 
          template <typename Allocator,
                    template <typename,typename> class Sequence>
-         inline expression_node_ptr const_optimize_mswitch(Sequence<expression_node_ptr,Allocator>& arg_list)
+         inline expression_node_ptr const_optimise_mswitch(Sequence<expression_node_ptr,Allocator>& arg_list)
          {
             expression_node_ptr result = error_node();
 
@@ -24224,7 +24318,7 @@ namespace exprtk
                return error_node();
             }
             else if (is_constant_foldable(arg_list))
-               return const_optimize_switch(arg_list);
+               return const_optimise_switch(arg_list);
 
             switch ((arg_list.size() - 1) / 2)
             {
@@ -24258,7 +24352,7 @@ namespace exprtk
                return error_node();
             }
             else if (is_constant_foldable(arg_list))
-               return const_optimize_mswitch(arg_list);
+               return const_optimise_mswitch(arg_list);
             else
                return node_allocator_->allocate<details::multi_switch_node<Type> >(arg_list);
          }
@@ -24353,7 +24447,7 @@ namespace exprtk
             }
          }
 
-         inline expression_node_ptr const_optimize_sf3(const details::operator_type& operation,
+         inline expression_node_ptr const_optimise_sf3(const details::operator_type& operation,
                                                        expression_node_ptr (&branch)[3])
          {
             expression_node_ptr temp_node = error_node();
@@ -24401,7 +24495,7 @@ namespace exprtk
             return node_allocator_->allocate<literal_node_t>(v);
          }
 
-         inline expression_node_ptr varnode_optimize_sf3(const details::operator_type& operation, expression_node_ptr (&branch)[3])
+         inline expression_node_ptr varnode_optimise_sf3(const details::operator_type& operation, expression_node_ptr (&branch)[3])
          {
             typedef details::variable_node<Type>* variable_ptr;
 
@@ -24450,9 +24544,9 @@ namespace exprtk
             if (!all_nodes_valid(branch))
                return error_node();
             else if (is_constant_foldable(branch))
-               return const_optimize_sf3(operation,branch);
+               return const_optimise_sf3(operation,branch);
             else if (all_nodes_variables(branch))
-               return varnode_optimize_sf3(operation,branch);
+               return varnode_optimise_sf3(operation,branch);
             else
             {
                switch (operation)
@@ -24491,7 +24585,7 @@ namespace exprtk
             }
          }
 
-         inline expression_node_ptr const_optimize_sf4(const details::operator_type& operation, expression_node_ptr (&branch)[4])
+         inline expression_node_ptr const_optimise_sf4(const details::operator_type& operation, expression_node_ptr (&branch)[4])
          {
             expression_node_ptr temp_node = error_node();
 
@@ -24538,7 +24632,7 @@ namespace exprtk
             return node_allocator_->allocate<literal_node_t>(v);
          }
 
-         inline expression_node_ptr varnode_optimize_sf4(const details::operator_type& operation, expression_node_ptr (&branch)[4])
+         inline expression_node_ptr varnode_optimise_sf4(const details::operator_type& operation, expression_node_ptr (&branch)[4])
          {
             typedef details::variable_node<Type>* variable_ptr;
 
@@ -24589,9 +24683,9 @@ namespace exprtk
             if (!all_nodes_valid(branch))
                return error_node();
             else if (is_constant_foldable(branch))
-               return const_optimize_sf4(operation,branch);
+               return const_optimise_sf4(operation,branch);
             else if (all_nodes_variables(branch))
-               return varnode_optimize_sf4(operation,branch);
+               return varnode_optimise_sf4(operation,branch);
             switch (operation)
             {
                #define case_stmt(op0,op1)                                                     \
@@ -24631,7 +24725,7 @@ namespace exprtk
 
          template <typename Allocator,
                    template <typename,typename> class Sequence>
-         inline expression_node_ptr const_optimize_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list)
+         inline expression_node_ptr const_optimise_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list)
          {
             expression_node_ptr temp_node = error_node();
 
@@ -24674,7 +24768,7 @@ namespace exprtk
 
          template <typename Allocator,
                    template <typename,typename> class Sequence>
-         inline expression_node_ptr varnode_optimize_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list)
+         inline expression_node_ptr varnode_optimise_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list)
          {
             switch (operation)
             {
@@ -24731,13 +24825,13 @@ namespace exprtk
                return error_node();
             }
             else if (is_constant_foldable(arg_list))
-               return const_optimize_varargfunc(operation,arg_list);
+               return const_optimise_varargfunc(operation,arg_list);
             else if ((arg_list.size() == 1) && details::is_ivector_node(arg_list[0]))
                return vectorize_func(operation,arg_list);
             else if ((arg_list.size() == 1) && special_one_parameter_vararg(operation))
                return arg_list[0];
             else if (all_nodes_variables(arg_list))
-               return varnode_optimize_varargfunc(operation,arg_list);
+               return varnode_optimise_varargfunc(operation,arg_list);
 
             switch (operation)
             {
@@ -24768,7 +24862,7 @@ namespace exprtk
                return error_node();
             else
             {
-               // Can the function call be completely optimized?
+               // Can the function call be completely optimised?
                if (details::is_constant_node(result))
                   return result;
                else if (!all_nodes_valid(b))
@@ -25519,8 +25613,8 @@ namespace exprtk
          case_stmt(details::e_xnor,details::xnor_op) \
 
          #ifndef exprtk_disable_cardinal_pow_optimisation
-         template <template <typename,typename> class IPowNode>
-         inline expression_node_ptr cardinal_pow_optimization_impl(const T& v, const unsigned int& p)
+         template <typename TType, template <typename,typename> class IPowNode>
+         inline expression_node_ptr cardinal_pow_optimisation_impl(const TType& v, const unsigned int& p)
          {
             switch (p)
             {
@@ -25548,7 +25642,7 @@ namespace exprtk
             }
          }
 
-         inline expression_node_ptr cardinal_pow_optimization(const T& v, const T& c)
+         inline expression_node_ptr cardinal_pow_optimisation(const T& v, const T& c)
          {
             const bool not_recipricol = (c >= T(0));
             const int p = details::numeric::to_int32(details::numeric::abs(c));
@@ -25563,26 +25657,50 @@ namespace exprtk
             else
             {
                if (not_recipricol)
-                  return cardinal_pow_optimization_impl<details::ipow_node>(v,p);
+                  return cardinal_pow_optimisation_impl<T,details::ipow_node>(v,p);
                else
-                  return cardinal_pow_optimization_impl<details::ipowinv_node>(v,p);
+                  return cardinal_pow_optimisation_impl<T,details::ipowinv_node>(v,p);
             }
          }
 
-         inline bool cardinal_pow_optimizable(const details::operator_type& operation, const T& c)
+         inline bool cardinal_pow_optimisable(const details::operator_type& operation, const T& c)
          {
             return (details::e_pow == operation) && (details::numeric::abs(c) <= T(60)) && details::numeric::is_integer(c);
          }
+
+         inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr (&branch)[2])
+         {
+            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
+            const bool not_recipricol = (c >= T(0));
+            const int p = details::numeric::to_int32(details::numeric::abs(c));
+
+            node_allocator_->free(branch[1]);
+
+            if (0 == p)
+            {
+               details::free_all_nodes(*node_allocator_, branch);
+               return node_allocator_->allocate_c<literal_node_t>(T(1));
+            }
+            else if (not_recipricol)
+               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipow_node>(branch[0],p);
+            else
+               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipowninv_node>(branch[0],p);
+         }
          #else
-         inline expression_node_ptr cardinal_pow_optimization(T&, const T&)
+         inline expression_node_ptr cardinal_pow_optimisation(T&, const T&)
          {
             return error_node();
          }
 
-         inline bool cardinal_pow_optimizable(const details::operator_type&, const T&)
+         inline bool cardinal_pow_optimisable(const details::operator_type&, const T&)
          {
             return false;
          }
+
+         inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr(&)[2])
+         {
+            return error_node();
+         }
          #endif
 
          struct synthesize_binary_ext_expression
@@ -26092,6 +26210,18 @@ namespace exprtk
                         return bocnode;
                      }
                   }
+                  else if (operation == details::e_pow)
+                  {
+                     // (v ^ c0) ^ c1 --> v ^(c0 * c1)
+                     details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]);
+                     details::operator_type boc_opr = bocnode->operation();
+
+                     if (details::e_pow == boc_opr)
+                     {
+                        bocnode->set_c(bocnode->c() * c);
+                        return bocnode;
+                     }
+                  }
                }
 
                #ifndef exprtk_disable_enhanced_features
@@ -26471,7 +26601,7 @@ namespace exprtk
          {
             result = error_node();
 
-            if (!operation_optimizable(operation))
+            if (!operation_optimisable(operation))
                return false;
 
             const std::string node_id = branch_to_id(branch);
@@ -26557,12 +26687,12 @@ namespace exprtk
 
                details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
-               if (expr_gen.cardinal_pow_optimizable(operation,c))
+               if (expr_gen.cardinal_pow_optimisable(operation,c))
                {
                   if (std::equal_to<T>()(T(1),c))
                      return branch[0];
                   else
-                     return expr_gen.cardinal_pow_optimization(v,c);
+                     return expr_gen.cardinal_pow_optimisation(v,c);
                }
                else if ((T(0) == c) && (details::e_mul == operation))
                   return expr_gen(T(0));
@@ -26631,7 +26761,7 @@ namespace exprtk
             {
                details::operator_type sf3opr;
 
-               if (!expr_gen.sf3_optimizable(id,sf3opr))
+               if (!expr_gen.sf3_optimisable(id,sf3opr))
                   return false;
                else
                   result = synthesize_sf3ext_expression::template process<T0,T1,T2>(expr_gen,sf3opr,t0,t1,t2);
@@ -26715,7 +26845,7 @@ namespace exprtk
             {
                details::operator_type sf4opr;
 
-               if (!expr_gen.sf4_optimizable(id,sf4opr))
+               if (!expr_gen.sf4_optimisable(id,sf4opr))
                   return false;
                else
                   result = synthesize_sf4ext_expression::template process<T0,T1,T2,T3>(expr_gen,sf4opr,t0,t1,t2,t3);
@@ -27731,6 +27861,14 @@ namespace exprtk
                      return expr_gen.node_allocator_->
                                template allocate_rc<typename details::voc_node<Type,details::div_op<Type> > >(v,c0 * c1);
                   }
+                  // (v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1)
+                  else if ((details::e_pow == o0) && (details::e_pow == o1))
+                  {
+                     exprtk_debug(("(v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1)\n"));
+
+                     return expr_gen.node_allocator_->
+                               template allocate_rc<typename details::voc_node<Type,details::pow_op<Type> > >(v,c0 * c1);
+                  }
                }
 
                if (synthesize_sf3ext_expression::template compile<vtype,ctype,ctype>(expr_gen,id(expr_gen,o0,o1),v,c0,c1,result))
@@ -31508,7 +31646,7 @@ namespace exprtk
             }
             else if ((details::e_default != operation))
             {
-               // Attempt simple constant folding optimization.
+               // Attempt simple constant folding optimisation.
                expression_node_ptr expression_point = node_allocator_->allocate<NodeType>(operation,branch);
 
                if (is_constant_foldable<N>(branch))
@@ -31537,7 +31675,7 @@ namespace exprtk
 
             typedef typename details::function_N_node<T,ifunction_t,N> function_N_node_t;
 
-            // Attempt simple constant folding optimization.
+            // Attempt simple constant folding optimisation.
 
             expression_node_ptr expression_point = node_allocator_->allocate<NodeType>(f);
             function_N_node_t* func_node_ptr = dynamic_cast<function_N_node_t*>(expression_point);
diff --git a/exprtk_test.cpp b/exprtk_test.cpp
index e5f7b32..0826c1e 100644
--- a/exprtk_test.cpp
+++ b/exprtk_test.cpp
@@ -2348,8 +2348,8 @@ inline bool run_test02()
                if (!parser.compile(test.expr, expression))
                {
                   printf("run_test02() - Error: %s   Expression: %s\n",
-                     parser.error().c_str(),
-                     test.expr.c_str());
+                         parser.error().c_str(),
+                         test.expr.c_str());
 
                   result = false;
                   continue;
@@ -2365,13 +2365,13 @@ inline bool run_test02()
             if (not_equal(expr_result, test.result))
             {
                printf("run_test02() - Computation Error:  Expression: [%s]\tExpected: %19.15f\tResult: %19.15f\t"
-                  "a='%s'\tb='%s'\tc='%s'\n",
-                  test.expr.c_str(),
-                  (double)test.result,
-                  (double)expr_result,
-                  str_a.c_str(),
-                  str_b.c_str(),
-                  str_c.c_str());
+                      "a='%s'\tb='%s'\tc='%s'\n",
+                      test.expr.c_str(),
+                      (double)test.result,
+                      (double)expr_result,
+                      str_a.c_str(),
+                      str_b.c_str(),
+                      str_c.c_str());
 
                result = false;
                continue;
@@ -6325,11 +6325,13 @@ inline bool run_test19()
                               104683,  104693,  104701,  104707,  104711,  104717,  104723,  104729,
                              1000621, 1000639, 1000651, 1000667, 1000669, 1001023, 1001027, 1001041
                            };
+
       const std::size_t prime_list_size = sizeof(prime_list) / sizeof(std::size_t);
 
       for (std::size_t i = 0; (i < prime_list_size) && (!failure); ++i)
       {
-         x = prime_list[i];
+         x = static_cast<T>(prime_list[i]);
+
          std::vector<T> result(expression_count,T(0));
 
          for (std::size_t j = 0; j < expression_list.size(); ++j)
@@ -6467,6 +6469,7 @@ inline bool run_test19()
               "x"));
 
       symbol_table_t& symbol_table = compositor.symbol_table();
+
       symbol_table.add_constants();
       symbol_table.add_variable("x",x);
 
@@ -6515,11 +6518,13 @@ inline bool run_test19()
                               46368,   75025, 121393,  196418,
                              317811,  514229, 832040, 1346269
                            };
+
       const std::size_t fibonacci_list_size = sizeof(fibonacci_list) / sizeof(std::size_t);
 
       for (std::size_t i = 0; (i < fibonacci_list_size) && (!failure); ++i)
       {
-         x = i;
+         x = static_cast<T>(i);
+
          std::vector<T> result(expression_count,T(0));
 
          for (std::size_t j = 0; j < expression_list.size(); ++j)
@@ -6629,7 +6634,8 @@ inline bool run_test19()
 
       for (std::size_t i = 0; i < 100; ++i)
       {
-         x = i;
+         x = static_cast<T>(i);
+
          T result = expression.value();
 
          if (not_equal(result,std::sqrt(x),T(0.0000001)))
@@ -6757,7 +6763,9 @@ inline bool run_test19()
       for (std::size_t i = 0; i < 100; ++i)
       {
          x = T(i);
+
          sum += x;
+
          T result = expression.value();
 
          if (result != sum)
@@ -6847,7 +6855,7 @@ struct my_usr : public exprtk::parser<T>::unknown_symbol_resolver
       {
          st = usr_t::e_usr_variable_type;
          default_value = next_value();
-         error_message = "";
+         error_message.clear();
 
          return true;
       }
@@ -6855,7 +6863,7 @@ struct my_usr : public exprtk::parser<T>::unknown_symbol_resolver
       {
          st = usr_t::e_usr_constant_type;
          default_value = next_value();
-         error_message = "";
+         error_message.clear();
 
          return true;
       }
diff --git a/readme.txt b/readme.txt
index ce2c8d1..845b689 100644
--- a/readme.txt
+++ b/readme.txt
@@ -7,7 +7,7 @@ mathematical  expression parsing  and evaluation  engine. The  parsing
 engine  supports numerous  forms  of  functional and  logic processing
 semantics and is easily extendible.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [01 - CAPABILITIES]
 The  ExprTk expression  evaluator supports  the following  fundamental
@@ -49,7 +49,7 @@ arithmetic operations, functions and processes:
 
  (11) Calculus:        numerical integration and differentiation
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [02 - EXAMPLE EXPRESSIONS]
 The  following  is  a  short listing  of  the  types  of  mathematical
@@ -76,7 +76,7 @@ expressions that can be parsed and evaluated using the ExprTk library.
   (19) ((x + 'abc') like '*123*') or ('a123b' ilike y)
   (20) sgn(+1.2^3.4z / -5.6y) <= {-7.8^9 / -10.11x }
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [03 - COPYRIGHT NOTICE]
 Free  use  of  the  C++  Mathematical  Expression  Toolkit  Library is
@@ -85,7 +85,7 @@ version of the Common Public License.
 
 http://www.opensource.org/licenses/cpl1.0.php
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [04 - DOWNLOADS & UPDATES]
 The most  recent version  of the C++ Mathematical  Expression  Toolkit
@@ -95,13 +95,13 @@ locations:
   (a) Download:   http://www.partow.net/programming/exprtk/index.html
   (b) Repository: https://github.com/ArashPartow/exprtk
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [05 - INSTALLATION]
 The header  file exprtk.hpp  should be  placed in a project or  system
 include path (e.g: /usr/include/).
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [06 - COMPILATION]
   (a) For a complete build: make clean all
@@ -109,7 +109,7 @@ include path (e.g: /usr/include/).
   (c) To strip executables: make strip_bin
   (d) Execute valgrind check: make valgrind_check
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [07 - COMPILER COMPATIBILITY]
 ExprTk has been built error and warning free using the following set
@@ -120,11 +120,10 @@ of C++ compilers:
   (*) Clang/LLVM (1.1+)
   (*) PGI C++ (10.x+)
   (*) Microsoft Visual Studio C++ Compiler (8.1+)
-  (*) Comeau C++ Compiler (4.3+)
   (*) IBM XL C/C++ (9.x+)
   (*) C++ Builder (XE4+)
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [08 - BUILT-IN OPERATIONS & FUNCTIONS]
 
@@ -604,7 +603,7 @@ appropriate may represent any of one the following:
    5. A string
    6. An expression comprised of [1], [2] or [3] (eg: 2 + x / vec[3])
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [09 - Fundamental Types]
 ExprTk supports three fundamental types which can be used freely in
@@ -635,7 +634,7 @@ can be  assigned and  concatenated to  one another,  they can  also be
 manipulated via sub-ranges using the range definition syntax.  Strings
 however can not interact with scalar or vector types.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [10 - COMPONENTS]
 There are three primary components, that are specialized upon a  given
@@ -794,7 +793,7 @@ The above denoted AST will be evaluated in the following order:
 
 
 (3) Parser
-A  structure  which  takes  as input  a  string  representation  of an
+A  component  which  takes  as input  a  string  representation  of an
 expression and attempts to compile said input with the result being an
 instance  of  Expression.  If  an  error  is  encountered  during  the
 compilation  process, the  parser will  stop compiling  and return  an
@@ -802,7 +801,7 @@ error status code,  with a more  detailed description of  the error(s)
 and  its  location  within  the  input  provided  by  the  'get_error'
 interface.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [11 - COMPILATION OPTIONS]
 The exprtk::parser  when being  instantiated takes  as input  a set of
@@ -937,7 +936,7 @@ desired over the strength reduced form. In these situations it is best
 to turn off strength reduction optimisations  or to use a type with  a
 larger numerical bound.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [12 - SPECIAL FUNCTIONS]
 The purpose  of special  functions in  ExprTk is  to provide  compiler
@@ -1008,7 +1007,7 @@ correctly optimize such expressions for a given architecture.
                                    $f98(x,y,z,w) | (x ==  y) ? z : w
                                    $f99(x,y,z,w) | x*sin(y)+z*cos(w)
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [13 - VARIABLE , VECTOR & STRING DEFINITION]
 ExprTk supports the definition of expression local variables,  vectors
@@ -1127,7 +1126,7 @@ based on the following priorities:
    (e) Symbol table functions
    (f) Unknown symbol resolver based variables
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [14 - VECTOR PROCESSING]
 ExprTk  provides  support  for   various  forms  of  vector   oriented
@@ -1203,7 +1202,7 @@ not a vector but rather a single value.
    min(1 / x)  == (1 / 3)
    max(x / 2)  == (3 / 2)
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [15 - USER DEFINED FUNCTIONS]
 ExprTk provides a means  whereby custom functions can  be defined  and
@@ -1310,6 +1309,7 @@ example defines a generic function called 'too':
          {
             ...
          }
+
          return T(0);
       }
    };
@@ -1735,7 +1735,7 @@ carried out:
       { ... }
    };
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [16 - EXPRESSION DEPENDENTS]
 Any  expression  that  is  not  a  literal  (aka  constant)  will have
@@ -1881,7 +1881,7 @@ of the DEC in determining the 'assignments' of the given expression:
 Note: The assignments will only consist of variable types and as  such
 will not contain symbols denoting functions.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [17 - ENABLING AND DISABLING FEATURES]
 The parser can be configured via its settings instance to either allow
@@ -2239,7 +2239,7 @@ provided symbol names when calling the standard 'add_function' method.
 Normally if  a user  specified symbol  name conflicts  with any of the
 ExprTk reserved words, the add_function call will fail.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [18 - EXPRESSION RETURN VALUES]
 ExprTk expressions can return immediately from any point by  utilizing
@@ -2291,7 +2291,7 @@ expression will return normally.
       typedef typename type_t::vector_view vector_t;
       typedef typename type_t::string_view string_t;
 
-      const results_context_t& result = expression.results();
+      const results_context_t& results = expression.results();
 
       for (std::size_t i = 0; i < results.count(); ++i)
       {
@@ -2313,10 +2313,10 @@ expression will return normally.
    }
 
 
-Note: Processing of the return results is very similar to that of  the
+Note: Processing of the return results is similar to that of the
 generic function call parameters.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [19 - COMPILATION ERRORS]
 When attempting to compile  a malformed or otherwise  erroneous ExprTk
@@ -2426,7 +2426,7 @@ find,  within  the  symbol_table,  symbols  representing  variables or
 functions, to being unable to create new variables in the symbol_table
 via the 'unknown symbol resolver' mechanism.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [20 - EXPRTK NOTES]
 The following is a list of facts and suggestions one may want to take
@@ -2604,7 +2604,7 @@ into account when using ExprTk:
         (x + y) / (x - y);
       }
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [21 - SIMPLE EXPRTK EXAMPLE]
 --- snip ---
@@ -2692,7 +2692,7 @@ int main()
 }
 --- snip ---
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [22 - BUILD OPTIONS]
 When building ExprTk there are a number of defines that will enable or
@@ -2738,7 +2738,7 @@ This  define  will  disable all  string  processing  capabilities. Any
 expression that contains a string or string related syntax will result
 in a compilation failure.
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [23 - FILES]
 The source distribution of ExprTk is comprised of the following set of
@@ -2766,7 +2766,7 @@ files:
    (19) exprtk_simple_example_15.cpp
    (20) exprtk_simple_example_16.cpp
 
-
+     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [24 - LANGUAGE STRUCTURE]
 +-------------------------------------------------------------+