diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 5ce5a53..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-language: cpp
-
-sudo: required
-
-dist: trusty
-
-compiler:
-  - gcc
-
-script:
-  - make clean all
-  - ./exprtk_test
diff --git a/exprtk.hpp b/exprtk.hpp
index acfa85c..dcec627 100644
--- a/exprtk.hpp
+++ b/exprtk.hpp
@@ -1111,13 +1111,21 @@
                   return T(0);
             }
 
+            #if (defined(_MSC_VER) && (_MSC_VER >= 1900)) || !defined(_MSC_VER)
+            #define exprtk_define_erf(TT,impl)           \
+            inline TT erf_impl(TT v) { return impl(v); } \
+
+            exprtk_define_erf(      float,::erff)
+            exprtk_define_erf(     double,::erf )
+            exprtk_define_erf(long double,::erfl)
+            #undef exprtk_define_erf
+            #endif
+
             template <typename T>
             inline T erf_impl(T v, real_type_tag)
             {
-               #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+               #if defined(_MSC_VER) && (_MSC_VER < 1900)
                // Credits: Abramowitz & Stegun Equations 7.1.25-28
-               const T t = T(1) / (T(1) + T(0.5) * abs_impl(v,real_type_tag()));
-
                static const T c[] = {
                                       T( 1.26551223), T(1.00002368),
                                       T( 0.37409196), T(0.09678418),
@@ -1126,6 +1134,8 @@
                                       T(-0.82215223), T(0.17087277)
                                     };
 
+               const T t = T(1) / (T(1) + T(0.5) * abs_impl(v,real_type_tag()));
+
                T result = T(1) - t * std::exp((-v * v) -
                                       c[0] + t * (c[1] + t *
                                      (c[2] + t * (c[3] + t *
@@ -1135,7 +1145,7 @@
 
                return (v >= T(0)) ? result : -result;
                #else
-               return ::erf(v);
+               return erf_impl(v);
                #endif
             }
 
@@ -1145,13 +1155,23 @@
                return erf_impl(static_cast<double>(v),real_type_tag());
             }
 
+            #if (defined(_MSC_VER) && (_MSC_VER >= 1900)) || !defined(_MSC_VER)
+            #define exprtk_define_erfc(TT,impl)           \
+            inline TT erfc_impl(TT v) { return impl(v); } \
+
+            exprtk_define_erfc(      float,::erfcf)
+            exprtk_define_erfc(     double,::erfc )
+            exprtk_define_erfc(long double,::erfcl)
+            #undef exprtk_define_erfc
+            #endif
+
             template <typename T>
             inline T erfc_impl(T v, real_type_tag)
             {
-               #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+               #if defined(_MSC_VER) && (_MSC_VER < 1900)
                return T(1) - erf_impl(v,real_type_tag());
                #else
-               return ::erfc(v);
+               return erfc_impl(v);
                #endif
             }
 
@@ -1196,7 +1216,7 @@
             template <typename T> inline T  asin_impl(const T v, real_type_tag) { return std::asin (v); }
             template <typename T> inline T asinh_impl(const T v, real_type_tag) { return std::log(v + std::sqrt((v * v) + T(1))); }
             template <typename T> inline T  atan_impl(const T v, real_type_tag) { return std::atan (v); }
-            template <typename T> inline T atanh_impl(const T v, real_type_tag) { return (std::log(T(1) + v) - log(T(1) - v)) / T(2); }
+            template <typename T> inline T atanh_impl(const T v, real_type_tag) { return (std::log(T(1) + v) - std::log(T(1) - v)) / T(2); }
             template <typename T> inline T  ceil_impl(const T v, real_type_tag) { return std::ceil (v); }
             template <typename T> inline T   cos_impl(const T v, real_type_tag) { return std::cos  (v); }
             template <typename T> inline T  cosh_impl(const T v, real_type_tag) { return std::cosh (v); }
@@ -1269,7 +1289,7 @@
          template <typename Type>
          struct numeric_info { enum { length = 0, size = 32, bound_length = 0, min_exp = 0, max_exp = 0 }; };
 
-         template<> struct numeric_info<int>         { enum { length = 10, size = 16, bound_length =  9}; };
+         template<> struct numeric_info<int>         { enum { length = 10, size = 16, bound_length = 9}; };
          template<> struct numeric_info<float>       { enum { min_exp =  -38, max_exp =  +38}; };
          template<> struct numeric_info<double>      { enum { min_exp = -308, max_exp = +308}; };
          template<> struct numeric_info<long double> { enum { min_exp = -308, max_exp = +308}; };
@@ -9223,8 +9243,8 @@
       };
 
       template <typename T, typename Operation>
-      class vecarith_vecvec_node : public binary_node     <T>,
-                                   public vector_interface<T>
+      class vec_binop_vecvec_node : public binary_node     <T>,
+                                    public vector_interface<T>
       {
       public:
 
@@ -9232,9 +9252,9 @@
          typedef vector_node<T>*       vector_node_ptr;
          typedef vector_holder<T>*   vector_holder_ptr;
 
-         vecarith_vecvec_node(const operator_type& opr,
-                              expression_ptr branch0,
-                              expression_ptr branch1)
+         vec_binop_vecvec_node(const operator_type& opr,
+                               expression_ptr branch0,
+                               expression_ptr branch1)
          : binary_node<T>(opr,branch0,branch1),
            vec0_node_ptr_(0),
            vec1_node_ptr_(0),
@@ -9286,7 +9306,7 @@
             }
          }
 
-        ~vecarith_vecvec_node()
+        ~vec_binop_vecvec_node()
          {
             delete[] data_;
             delete   temp_;
@@ -9388,8 +9408,8 @@
       };
 
       template <typename T, typename Operation>
-      class vecarith_vecval_node : public binary_node     <T>,
-                                   public vector_interface<T>
+      class vec_binop_vecval_node : public binary_node     <T>,
+                                    public vector_interface<T>
       {
       public:
 
@@ -9397,9 +9417,9 @@
          typedef vector_node<T>*       vector_node_ptr;
          typedef vector_holder<T>*   vector_holder_ptr;
 
-         vecarith_vecval_node(const operator_type& opr,
-                              expression_ptr branch0,
-                              expression_ptr branch1)
+         vec_binop_vecval_node(const operator_type& opr,
+                               expression_ptr branch0,
+                               expression_ptr branch1)
          : binary_node<T>(opr,branch0,branch1),
            vec0_node_ptr_(0),
            vec_size_     (0),
@@ -9432,7 +9452,7 @@
             }
          }
 
-        ~vecarith_vecval_node()
+        ~vec_binop_vecval_node()
          {
             delete[] data_;
             delete   temp_;
@@ -9530,8 +9550,8 @@
       };
 
       template <typename T, typename Operation>
-      class vecarith_valvec_node : public binary_node     <T>,
-                                   public vector_interface<T>
+      class vec_binop_valvec_node : public binary_node     <T>,
+                                    public vector_interface<T>
       {
       public:
 
@@ -9539,9 +9559,9 @@
          typedef vector_node<T>*       vector_node_ptr;
          typedef vector_holder<T>*   vector_holder_ptr;
 
-         vecarith_valvec_node(const operator_type& opr,
-                              expression_ptr branch0,
-                              expression_ptr branch1)
+         vec_binop_valvec_node(const operator_type& opr,
+                               expression_ptr branch0,
+                               expression_ptr branch1)
          : binary_node<T>(opr,branch0,branch1),
            vec1_node_ptr_(0),
            vec_size_     (0),
@@ -9574,7 +9594,7 @@
             }
          }
 
-        ~vecarith_valvec_node()
+        ~vec_binop_valvec_node()
          {
             delete[] data_;
             delete   temp_;
@@ -21646,7 +21666,7 @@
                {
                   invalid_state_ = false;
 
-                  const std::string err_param_seq =  s.substr(start,end - start);
+                  const std::string err_param_seq = s.substr(start,end - start);
 
                   parser_.
                      set_error(
@@ -21667,7 +21687,7 @@
                   param_seq_list_ = param_seq_list;
                else
                {
-                  const std::string err_param_seq =  s.substr(start,s.size() - start);
+                  const std::string err_param_seq = s.substr(start,s.size() - start);
 
                   parser_.
                      set_error(
@@ -24282,7 +24302,7 @@
                    );
          }
 
-         inline bool is_vector_eqineq_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2])
+         inline bool is_vector_eqineq_logic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2])
          {
             if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1]))
                return false;
@@ -24294,7 +24314,13 @@
                         (details::e_gte    == operation) ||
                         (details::e_eq     == operation) ||
                         (details::e_ne     == operation) ||
-                        (details::e_equal  == operation)
+                        (details::e_equal  == operation) ||
+                        (details::e_and    == operation) ||
+                        (details::e_nand   == operation) ||
+                        (details::  e_or   == operation) ||
+                        (details:: e_nor   == operation) ||
+                        (details:: e_xor   == operation) ||
+                        (details::e_xnor   == operation)
                       );
          }
 
@@ -24328,8 +24354,8 @@
                return synthesize_swap_expression(branch);
             else if (is_assignment_operation(operation))
                return synthesize_assignment_operation_expression(operation,branch);
-            else if (is_vector_eqineq_operation(operation,branch))
-               return synthesize_veceqineq_operation_expression(operation,branch);
+            else if (is_vector_eqineq_logic_operation(operation,branch))
+               return synthesize_veceqineqlogic_operation_expression(operation,branch);
             else if (is_vector_arithmetic_operation(operation,branch))
                return synthesize_vecarithmetic_operation_expression(operation,branch);
             else if (is_shortcircuit_expression(operation))
@@ -25778,28 +25804,37 @@
             }
          }
 
-         inline expression_node_ptr synthesize_veceqineq_operation_expression(const details::operator_type& operation,
-                                                                              expression_node_ptr (&branch)[2])
+         inline expression_node_ptr synthesize_veceqineqlogic_operation_expression(const details::operator_type& operation,
+                                                                                   expression_node_ptr (&branch)[2])
          {
             const bool is_b0_ivec = details::is_ivector_node(branch[0]);
             const bool is_b1_ivec = details::is_ivector_node(branch[1]);
 
+            #define batch_eqineq_logic_case               \
+            case_stmt(details::   e_lt,details::   lt_op) \
+            case_stmt(details::  e_lte,details::  lte_op) \
+            case_stmt(details::   e_gt,details::   gt_op) \
+            case_stmt(details::  e_gte,details::  gte_op) \
+            case_stmt(details::   e_eq,details::   eq_op) \
+            case_stmt(details::   e_ne,details::   ne_op) \
+            case_stmt(details::e_equal,details::equal_op) \
+            case_stmt(details::  e_and,  details::and_op) \
+            case_stmt(details:: e_nand, details::nand_op) \
+            case_stmt(details::   e_or, details::  or_op) \
+            case_stmt(details::  e_nor, details:: nor_op) \
+            case_stmt(details::  e_xor, details:: xor_op) \
+            case_stmt(details:: e_xnor, details::xnor_op) \
+
             if (is_b0_ivec && is_b1_ivec)
             {
                switch (operation)
                {
-                  #define case_stmt(op0,op1)                                                                    \
-                  case op0 : return node_allocator_->                                                           \
-                                template allocate_rrr<typename details::vecarith_vecvec_node<Type,op1<Type> > > \
-                                   (operation,branch[0],branch[1]);                                             \
+                  #define case_stmt(op0,op1)                                                                     \
+                  case op0 : return node_allocator_->                                                            \
+                                template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
+                                   (operation,branch[0],branch[1]);                                              \
 
-                  case_stmt(details::   e_lt,details::   lt_op)
-                  case_stmt(details::  e_lte,details::  lte_op)
-                  case_stmt(details::   e_gt,details::   gt_op)
-                  case_stmt(details::  e_gte,details::  gte_op)
-                  case_stmt(details::   e_eq,details::   eq_op)
-                  case_stmt(details::   e_ne,details::   ne_op)
-                  case_stmt(details::e_equal,details::equal_op)
+                  batch_eqineq_logic_case
                   #undef case_stmt
                   default : return error_node();
                }
@@ -25808,18 +25843,12 @@
             {
                switch (operation)
                {
-                  #define case_stmt(op0,op1)                                                                    \
-                  case op0 : return node_allocator_->                                                           \
-                                template allocate_rrr<typename details::vecarith_vecval_node<Type,op1<Type> > > \
-                                   (operation,branch[0],branch[1]);                                             \
+                  #define case_stmt(op0,op1)                                                                     \
+                  case op0 : return node_allocator_->                                                            \
+                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
+                                   (operation,branch[0],branch[1]);                                              \
 
-                  case_stmt(details::   e_lt,details::   lt_op)
-                  case_stmt(details::  e_lte,details::  lte_op)
-                  case_stmt(details::   e_gt,details::   gt_op)
-                  case_stmt(details::  e_gte,details::  gte_op)
-                  case_stmt(details::   e_eq,details::   eq_op)
-                  case_stmt(details::   e_ne,details::   ne_op)
-                  case_stmt(details::e_equal,details::equal_op)
+                  batch_eqineq_logic_case
                   #undef case_stmt
                   default : return error_node();
                }
@@ -25828,24 +25857,20 @@
             {
                switch (operation)
                {
-                  #define case_stmt(op0,op1)                                                                    \
-                  case op0 : return node_allocator_->                                                           \
-                                template allocate_rrr<typename details::vecarith_valvec_node<Type,op1<Type> > > \
-                                   (operation,branch[0],branch[1]);                                             \
+                  #define case_stmt(op0,op1)                                                                     \
+                  case op0 : return node_allocator_->                                                            \
+                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
+                                   (operation,branch[0],branch[1]);                                              \
 
-                  case_stmt(details::   e_lt,details::   lt_op)
-                  case_stmt(details::  e_lte,details::  lte_op)
-                  case_stmt(details::   e_gt,details::   gt_op)
-                  case_stmt(details::  e_gte,details::  gte_op)
-                  case_stmt(details::   e_eq,details::   eq_op)
-                  case_stmt(details::   e_ne,details::   ne_op)
-                  case_stmt(details::e_equal,details::equal_op)
+                  batch_eqineq_logic_case
                   #undef case_stmt
                   default : return error_node();
                }
             }
             else
                return error_node();
+
+            #undef batch_eqineq_logic_case
          }
 
          inline expression_node_ptr synthesize_vecarithmetic_operation_expression(const details::operator_type& operation,
@@ -25865,10 +25890,10 @@
             {
                switch (operation)
                {
-                  #define case_stmt(op0,op1)                                                                    \
-                  case op0 : return node_allocator_->                                                           \
-                                template allocate_rrr<typename details::vecarith_vecvec_node<Type,op1<Type> > > \
-                                   (operation,branch[0],branch[1]);                                             \
+                  #define case_stmt(op0,op1)                                                                     \
+                  case op0 : return node_allocator_->                                                            \
+                                template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
+                                   (operation,branch[0],branch[1]);                                              \
 
                   vector_ops
                   case_stmt(details::e_pow,details:: pow_op)
@@ -25880,10 +25905,10 @@
             {
                switch (operation)
                {
-                  #define case_stmt(op0,op1)                                                                    \
-                  case op0 : return node_allocator_->                                                           \
-                                template allocate_rrr<typename details::vecarith_vecval_node<Type,op1<Type> > > \
-                                   (operation,branch[0],branch[1]);                                             \
+                  #define case_stmt(op0,op1)                                                                     \
+                  case op0 : return node_allocator_->                                                            \
+                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
+                                   (operation,branch[0],branch[1]);                                              \
 
                   vector_ops
                   case_stmt(details::e_pow,details:: pow_op)
@@ -25895,10 +25920,10 @@
             {
                switch (operation)
                {
-                  #define case_stmt(op0,op1)                                                                    \
-                  case op0 : return node_allocator_->                                                           \
-                                template allocate_rrr<typename details::vecarith_valvec_node<Type,op1<Type> > > \
-                                   (operation,branch[0],branch[1]);                                             \
+                  #define case_stmt(op0,op1)                                                                     \
+                  case op0 : return node_allocator_->                                                            \
+                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
+                                   (operation,branch[0],branch[1]);                                              \
 
                   vector_ops
                   #undef case_stmt
diff --git a/exprtk_benchmark.cpp b/exprtk_benchmark.cpp
index 26e5e3d..e64c395 100644
--- a/exprtk_benchmark.cpp
+++ b/exprtk_benchmark.cpp
@@ -183,7 +183,7 @@
    return true;
 }
 
-const double pi = 3.14159265358979323846;
+const double pi = 3.141592653589793238462643383279502;
 
 template <typename T>
 struct native
diff --git a/exprtk_simple_example_02.cpp b/exprtk_simple_example_02.cpp
index 3d707ab..d8859d9 100644
--- a/exprtk_simple_example_02.cpp
+++ b/exprtk_simple_example_02.cpp
@@ -37,7 +37,7 @@
                              " (1/21)*sin(42*pi*f*t)+(1/23)*sin(46*pi*f*t)+"
                              " (1/25)*sin(50*pi*f*t)+(1/27)*sin(54*pi*f*t))";
 
-   static const T pi = T(3.14159265358979323846);
+   static const T pi = T(3.141592653589793238462643383279502);
 
    T f = pi / T(10);
    T t = T(0);
diff --git a/exprtk_simple_example_11.cpp b/exprtk_simple_example_11.cpp
index 4852155..3ecb6eb 100644
--- a/exprtk_simple_example_11.cpp
+++ b/exprtk_simple_example_11.cpp
@@ -36,7 +36,7 @@
                   " };                                                  "
                   " r *= a * (4 / pi);                                  ";
 
-   static const T pi = T(3.14159265358979323846);
+   static const T pi = T(3.141592653589793238462643383279502);
 
    T f = pi / T(10);
    T t = T(0);
diff --git a/exprtk_simple_example_13.cpp b/exprtk_simple_example_13.cpp
index 30e2372..36ed5fd 100644
--- a/exprtk_simple_example_13.cpp
+++ b/exprtk_simple_example_13.cpp
@@ -61,7 +61,7 @@
    std::vector<T> v_in;
    std::vector<T> v_out;
 
-   const T pi = T(3.141592653589793238462);
+   const T pi = T(3.141592653589793238462643383279502);
 
    srand(static_cast<unsigned int>(time(0)));
 
diff --git a/exprtk_simple_example_17.cpp b/exprtk_simple_example_17.cpp
index 9534bbc..997482a 100644
--- a/exprtk_simple_example_17.cpp
+++ b/exprtk_simple_example_17.cpp
@@ -33,7 +33,8 @@
    inline T operator()()
    {
       // Note: Do not use this in production
-      return T(::rand() / T(RAND_MAX + 1));
+      // Result is in the interval [0,1)
+      return T(::rand() / T(RAND_MAX + 1.0));
    }
 };
 
@@ -61,7 +62,7 @@
 
    const T approximate_pi = expression.value();
 
-   const T real_pi = T(3.141592653589793238462);
+   const T real_pi = T(3.141592653589793238462643383279502); // or close enough...
 
    printf("pi ~ %20.17f\terror: %20.17f\n",
           approximate_pi,
diff --git a/exprtk_test.cpp b/exprtk_test.cpp
index 66d4779..8878f5a 100644
--- a/exprtk_test.cpp
+++ b/exprtk_test.cpp
@@ -29,7 +29,12 @@
 #include "exprtk.hpp"
 
 
+#ifdef exprtk_test_float32_type
+typedef float numeric_type;
+#else
 typedef double numeric_type;
+#endif
+
 typedef std::pair<std::string,numeric_type> test_t;
 
 static const test_t global_test_list[] =
@@ -2750,7 +2755,7 @@
       }
    }
 
-   const T pi = T(3.14159265358979323846);
+   const T pi = T(3.141592653589793238462643383279502);
    const T increment = T(0.0001);
 
    while ((x <= T(+1000)) && (y <= T(+1000)))
@@ -2815,7 +2820,7 @@
       expression_list.push_back(e);
    }
 
-   const T pi = T(3.14159265358979323846);
+   const T pi = T(3.141592653589793238462643383279502);
    const T increment = T(0.001);
 
    while ((x <= T(+1000)) && (y <= T(+1000)))
@@ -2878,7 +2883,7 @@
 
    T total_area1 = exprtk::integrate(expression,x,T(-1),T(1));
    T total_area2 = exprtk::integrate(expression,"x",T(-1),T(1));
-   const T pi = T(3.14159265358979323846);
+   const T pi = T(3.141592653589793238462643383279502);
 
    if (not_equal(total_area1,total_area2,T(0.000001)))
    {
@@ -3196,12 +3201,16 @@
    }
 };
 
-double foo1(double v0) { return v0; }
-double foo2(double v0, double v1) { return v0 + v1; }
-double foo3(double v0, double v1, double v2) { return v0 + v1 + v2; }
-double foo4(double v0, double v1, double v2, double v3) { return v0 + v1 + v2 + v3; }
-double foo5(double v0, double v1, double v2, double v3, double v4) { return v0 + v1 + v2 + v3 + v4; }
-double foo6(double v0, double v1, double v2, double v3, double v4, double v5) { return v0 + v1 + v2 + v3 + v4 + v5; }
+#define define_free_functions(Type)                                                                     \
+Type foo1(Type v0) { return v0; }                                                                       \
+Type foo2(Type v0, Type v1) { return v0 + v1; }                                                         \
+Type foo3(Type v0, Type v1, Type v2) { return v0 + v1 + v2; }                                           \
+Type foo4(Type v0, Type v1, Type v2, Type v3) { return v0 + v1 + v2 + v3; }                             \
+Type foo5(Type v0, Type v1, Type v2, Type v3, Type v4) { return v0 + v1 + v2 + v3 + v4; }               \
+Type foo6(Type v0, Type v1, Type v2, Type v3, Type v4, Type v5) { return v0 + v1 + v2 + v3 + v4 + v5; } \
+
+define_free_functions(numeric_type)
+#undef define_free_functions
 
 template <typename T>
 inline bool run_test09()
@@ -3267,7 +3276,7 @@
             }
          }
 
-         const T pi = T(3.141592653589793238462);
+         const T pi = T(3.141592653589793238462643383279502);
 
          T result = expression.value();
 
diff --git a/readme.txt b/readme.txt
index 2ed1891..3a9d955 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1269,12 +1269,13 @@
    (b) Exponentiation:   vector ^ scalar
    (c) Assignment:       :=, +=, -=, *=, /=, %=, <=>
    (d) Inequalities:     <, <=, >, >=, ==, =, equal
-   (e) Unary operations:
+   (e) Boolean logic:    and, nand, nor, or, xnor, xor
+   (f) Unary operations:
        abs, acos, acosh, asin, asinh, atan, atanh, ceil, cos,  cosh,
        cot, csc,  deg2grad, deg2rad,  erf, erfc,  exp, expm1, floor,
        frac, grad2deg, log, log10, log1p, log2, rad2deg, round, sec,
        sgn, sin, sinc, sinh, sqrt, swap, tan, tanh, trunc
-   (f) Aggregate and Reduce operations:
+   (g) Aggregate and Reduce operations:
        avg, max, min, mul, sum
 
 Note: When one of  the above  described operations  is being performed
@@ -1315,6 +1316,7 @@
    avg(3x + 1) ==  7
    min(1 / x)  == (1 / 3)
    max(x / 2)  == (3 / 2)
+   sum(x > 0 and x < 5) == x[]
 
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -2487,6 +2489,16 @@
    }
 
 
+Assuming the  following expression '2 + (3 / log(1 + x))' which uses a
+variable named 'x'  that has not been registered  with the appropriate
+symbol_table  instance and  is not  a locally  defined variable,  once
+compiled the  above denoted post compilation error handling code shall
+produce the following output:
+
+  Error: ERR184 - Undefined symbol: 'x'
+  Err No.:00 Pos:17  Type:[Syntax] Msg: ERR184 - Undefined symbol: 'x'
+
+
 For  expressions  comprised  of  multiple  lines,  the  error position
 provided in the  parser_error object can  be converted into  a pair of
 line and column numbers by invoking the 'update_error' function as  is
@@ -2730,9 +2742,40 @@
         (x + y) / (x - y);
       }
 
+ (30) For performance considerations,  one should assume  the actions
+      of expression, symbol  table and parser  instance instantiation
+      and destruction, and the expression compilation process  itself
+      to be of high latency. Hence none of them should be part of any
+      performance  critical  code  paths, and  should  instead  occur
+      entirely either before or after such code paths.
+
+ (31) Before jumping in and using ExprTk, do take the time to  peruse
+      the documentation and all of the examples, both in the main and
+      the extras  distributions. Having  an informed  general view of
+      what can and  can't be done,  and how something  should be done
+      with ExprTk, will  likely result in  a far more  productive and
+      enjoyable programming experience.
+
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [21 - SIMPLE EXPRTK EXAMPLE]
+The following is a  simple yet complete example  demonstrating typical
+usage of the ExprTk Library.  The example instantiates a symbol  table
+object, adding to it  three variables named x,  y and z, and  a custom
+user defined function, that accepts only two parameters, named myfunc.
+The  example then  proceeds to  instantiate an  expression object  and
+register to it the symbol table instance.
+
+A parser is  then instantiated, and  the string representation  of the
+expression  and  the  expression object  are  passed  to the  parser's
+compile  method   for  compilation.   If  an   error  occurred  during
+compilation, the compile method will return false, leading to a series
+of  error diagnostics  being printed  to stdout.  Otherwise the  newly
+compiled expression is evaluated  by invoking  the expression object's
+value method, and subsequently printing the result  of the computation
+to stdout.
+
+
 --- snip ---
 #include <cstdio>
 #include <string>