C++ Mathematical Expression Library (ExprTk) https://www.partow.net/programming/exprtk/index.html
diff --git a/exprtk.hpp b/exprtk.hpp index dcec627..dc5e775 100644 --- a/exprtk.hpp +++ b/exprtk.hpp
@@ -2996,6 +2996,8 @@ { public: + using lexer::token_inserter::insert; + commutative_inserter() : lexer::token_inserter(2) {} @@ -3228,6 +3230,8 @@ { public: + using lexer::token_scanner::operator(); + bracket_checker() : token_scanner(1), state_(true) @@ -3311,6 +3315,8 @@ { public: + using lexer::token_scanner::operator(); + numeric_checker() : token_scanner (1), current_index_(0) @@ -3444,6 +3450,8 @@ public: + using lexer::token_scanner::operator(); + sequence_validator() : lexer::token_scanner(2) { @@ -5338,12 +5346,18 @@ switch (operation_) { case e_inrange : return (arg1 < arg0) ? T(0) : ((arg1 > arg2) ? T(0) : T(1)); + case e_clamp : return (arg1 < arg0) ? arg0 : (arg1 > arg2 ? arg2 : arg1); + case e_iclamp : if ((arg1 <= arg0) || (arg1 >= arg2)) return arg1; else return ((T(2) * arg1 <= (arg2 + arg0)) ? arg0 : arg2); - default : return std::numeric_limits<T>::quiet_NaN(); + + default : { + exprtk_debug(("trinary_node::value() - Error: Invalid operation\n")); + return std::numeric_limits<T>::quiet_NaN(); + } } } @@ -14827,6 +14841,8 @@ struct freefunc1 : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + freefunc1(ff1_functor ff) : exprtk::ifunction<T>(1), f(ff) {} inline T operator()(const T& v0) { return f(v0); } @@ -14835,6 +14851,8 @@ struct freefunc2 : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + freefunc2(ff2_functor ff) : exprtk::ifunction<T>(2), f(ff) {} inline T operator()(const T& v0, const T& v1) { return f(v0,v1); } @@ -14843,6 +14861,8 @@ struct freefunc3 : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + freefunc3(ff3_functor ff) : exprtk::ifunction<T>(3), f(ff) {} inline T operator()(const T& v0, const T& v1, const T& v2) { return f(v0,v1,v2); } @@ -14851,6 +14871,8 @@ struct freefunc4 : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + freefunc4(ff4_functor ff) : exprtk::ifunction<T>(4), f(ff) {} inline T operator()(const T& v0, const T& v1, const T& v2, const T& v3) { return f(v0,v1,v2,v3); } @@ -14859,6 +14881,8 @@ struct freefunc5 : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + freefunc5(ff5_functor ff) : exprtk::ifunction<T>(5), f(ff) {} inline T operator()(const T& v0, const T& v1, const T& v2, const T& v3, const T& v4) { return f(v0,v1,v2,v3,v4); } @@ -14867,6 +14891,8 @@ struct freefunc6 : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + freefunc6(ff6_functor ff) : exprtk::ifunction<T>(6), f(ff) {} inline T operator()(const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) { return f(v0,v1,v2,v3,v4,v5); } @@ -15258,7 +15284,7 @@ static const std::size_t lut_size = 256; // Symbol Table Holder - struct st_holder + struct control_block { struct st_data { @@ -15304,17 +15330,17 @@ std::vector<ifunction<T>*> free_function_list_; }; - st_holder() + control_block() : ref_count(1), data_(new st_data) {} - st_holder(st_data* data) + control_block(st_data* data) : ref_count(1), data_(data) {} - ~st_holder() + ~control_block() { if (data_ && (0 == ref_count)) { @@ -15323,6 +15349,11 @@ } } + static control_block* create() + { + return new control_block; + } + std::size_t ref_count; st_data* data_; }; @@ -15330,45 +15361,45 @@ public: symbol_table() - : holder_(new st_holder) + : control_block_(control_block::create()) { clear(); } ~symbol_table() { - if (holder_) + if (control_block_) { - if (0 == --holder_->ref_count) + if (0 == --control_block_->ref_count) { clear(); - delete holder_; + delete control_block_; } } } symbol_table(const symbol_table<T>& st) { - holder_ = st.holder_; - holder_->ref_count++; + control_block_ = st.control_block_; + control_block_->ref_count++; } inline symbol_table<T>& operator=(const symbol_table<T>& st) { if (this != &st) { - if (holder_) + if (control_block_) { - if (0 == --holder_->ref_count) + if (0 == --control_block_->ref_count) { - delete holder_; + delete control_block_; } - holder_ = 0; + control_block_ = 0; } - holder_ = st.holder_; - holder_->ref_count++; + control_block_ = st.control_block_; + control_block_->ref_count++; } return *this; @@ -15376,7 +15407,7 @@ inline bool operator==(const symbol_table<T>& st) { - return (this == &st) || (holder_ == st.holder_); + return (this == &st) || (control_block_ == st.control_block_); } inline void clear_variables(const bool delete_node = true) @@ -16090,7 +16121,7 @@ inline bool valid() const { // Symbol table sanity check. - return holder_ && holder_->data_; + return control_block_ && control_block_->data_; } inline void load_from(const symbol_table<T>& st) @@ -16206,19 +16237,19 @@ return true; } - typedef typename st_holder::st_data local_data_t; + typedef typename control_block::st_data local_data_t; inline local_data_t& local_data() { - return *(holder_->data_); + return *(control_block_->data_); } inline const local_data_t& local_data() const { - return *(holder_->data_); + return *(control_block_->data_); } - st_holder* holder_; + control_block* control_block_; friend class parser<T>; }; @@ -16235,7 +16266,7 @@ typedef details::vector_holder<T>* vector_holder_ptr; typedef std::vector<symbol_table<T> > symtab_list_t; - struct expression_holder + struct control_block { enum data_type { @@ -16269,7 +16300,7 @@ typedef std::vector<data_pack> local_data_list_t; typedef results_context<T> results_context_t; - expression_holder() + control_block() : ref_count(0), expr (0), results (0), @@ -16277,7 +16308,7 @@ return_invoked(&retinv_null) {} - expression_holder(expression_ptr e) + control_block(expression_ptr e) : ref_count(1), expr (e), results (0), @@ -16285,7 +16316,7 @@ return_invoked(&retinv_null) {} - ~expression_holder() + ~control_block() { if (expr && details::branch_deletable(expr)) { @@ -16324,6 +16355,24 @@ } } + static inline control_block* create(expression_ptr e) + { + return new control_block(e); + } + + static inline void destroy(control_block*& cntrl_blck) + { + if (cntrl_blck) + { + if (0 == --cntrl_blck->ref_count) + { + delete cntrl_blck; + } + + cntrl_blck = 0; + } + } + std::size_t ref_count; expression_ptr expr; local_data_list_t local_data_list; @@ -16337,34 +16386,34 @@ public: expression() - : expression_holder_(0) + : control_block_(0) { set_expression(new details::null_node<T>()); } expression(const expression<T>& e) - : expression_holder_(e.expression_holder_), + : control_block_(e.control_block_), symbol_table_list_(e.symbol_table_list_) { - expression_holder_->ref_count++; + control_block_->ref_count++; } inline expression<T>& operator=(const expression<T>& e) { if (this != &e) { - if (expression_holder_) + if (control_block_) { - if (0 == --expression_holder_->ref_count) + if (0 == --control_block_->ref_count) { - delete expression_holder_; + delete control_block_; } - expression_holder_ = 0; + control_block_ = 0; } - expression_holder_ = e.expression_holder_; - expression_holder_->ref_count++; + control_block_ = e.control_block_; + control_block_->ref_count++; symbol_table_list_ = e.symbol_table_list_; } @@ -16379,40 +16428,26 @@ inline bool operator!() const { return ( - (0 == expression_holder_ ) || - (0 == expression_holder_->expr) + (0 == control_block_ ) || + (0 == control_block_->expr) ); } inline expression<T>& release() { - if (expression_holder_) - { - if (0 == --expression_holder_->ref_count) - { - delete expression_holder_; - } - - expression_holder_ = 0; - } + control_block::destroy(control_block_); return *this; } ~expression() { - if (expression_holder_) - { - if (0 == --expression_holder_->ref_count) - { - delete expression_holder_; - } - } + control_block::destroy(control_block_); } inline T value() const { - return expression_holder_->expr->value(); + return control_block_->expr->value(); } inline T operator()() const @@ -16449,8 +16484,8 @@ inline const results_context_t& results() const { - if (expression_holder_->results) - return (*expression_holder_->results); + if (control_block_->results) + return (*control_block_->results); else { static const results_context_t null_results; @@ -16460,7 +16495,7 @@ inline bool return_invoked() const { - return (*expression_holder_->return_invoked); + return (*control_block_->return_invoked); } private: @@ -16474,15 +16509,15 @@ { if (expr) { - if (expression_holder_) + if (control_block_) { - if (0 == --expression_holder_->ref_count) + if (0 == --control_block_->ref_count) { - delete expression_holder_; + delete control_block_; } } - expression_holder_ = new expression_holder(expr); + control_block_ = control_block::create(expr); } } @@ -16490,13 +16525,13 @@ { if (expr) { - if (expression_holder_) + if (control_block_) { - expression_holder_-> + control_block_-> local_data_list.push_back( - typename expression<T>::expression_holder:: + typename expression<T>::control_block:: data_pack(reinterpret_cast<void*>(expr), - expression_holder::e_expr)); + control_block::e_expr)); } } } @@ -16505,13 +16540,13 @@ { if (vec_holder) { - if (expression_holder_) + if (control_block_) { - expression_holder_-> + control_block_-> local_data_list.push_back( - typename expression<T>::expression_holder:: + typename expression<T>::control_block:: data_pack(reinterpret_cast<void*>(vec_holder), - expression_holder::e_vecholder)); + control_block::e_vecholder)); } } } @@ -16520,55 +16555,55 @@ { if (data) { - if (expression_holder_) + if (control_block_) { - typename expression_holder::data_type dt = expression_holder::e_data; + typename control_block::data_type dt = control_block::e_data; switch (data_mode) { - case 0 : dt = expression_holder::e_data; break; - case 1 : dt = expression_holder::e_vecdata; break; - case 2 : dt = expression_holder::e_string; break; + case 0 : dt = control_block::e_data; break; + case 1 : dt = control_block::e_vecdata; break; + case 2 : dt = control_block::e_string; break; } - expression_holder_-> + control_block_-> local_data_list.push_back( - typename expression<T>::expression_holder:: + typename expression<T>::control_block:: data_pack(reinterpret_cast<void*>(data),dt,size)); } } } - inline const typename expression_holder::local_data_list_t& local_data_list() + inline const typename control_block::local_data_list_t& local_data_list() { - if (expression_holder_) + if (control_block_) { - return expression_holder_->local_data_list; + return control_block_->local_data_list; } else { - static typename expression_holder::local_data_list_t null_local_data_list; + static typename control_block::local_data_list_t null_local_data_list; return null_local_data_list; } } inline void register_return_results(results_context_t* rc) { - if (expression_holder_ && rc) + if (control_block_ && rc) { - expression_holder_->results = rc; + control_block_->results = rc; } } inline void set_retinvk(bool* retinvk_ptr) { - if (expression_holder_) + if (control_block_) { - expression_holder_->return_invoked = retinvk_ptr; + control_block_->return_invoked = retinvk_ptr; } } - expression_holder* expression_holder_; + control_block* control_block_; symtab_list_t symbol_table_list_; friend class parser<T>; @@ -16583,27 +16618,27 @@ static inline bool is_constant(const expression<T>& expr) { - return details::is_constant_node(expr.expression_holder_->expr); + return details::is_constant_node(expr.control_block_->expr); } static inline bool is_variable(const expression<T>& expr) { - return details::is_variable_node(expr.expression_holder_->expr); + return details::is_variable_node(expr.control_block_->expr); } static inline bool is_unary(const expression<T>& expr) { - return details::is_unary_node(expr.expression_holder_->expr); + return details::is_unary_node(expr.control_block_->expr); } static inline bool is_binary(const expression<T>& expr) { - return details::is_binary_node(expr.expression_holder_->expr); + return details::is_binary_node(expr.control_block_->expr); } static inline bool is_function(const expression<T>& expr) { - return details::is_function(expr.expression_holder_->expr); + return details::is_function(expr.control_block_->expr); } }; @@ -22163,6 +22198,7 @@ bool single_value_initialiser = false; bool vec_to_vec_initialiser = false; + bool null_initialisation = false; if (!token_is(token_t::e_rsqrbracket)) { @@ -22239,19 +22275,25 @@ else return error_node(); } + // Are we dealing with a null initialisation vector definition? + else if (token_is(token_t::e_symbol,"null")) + null_initialisation = true; } - if (0 == initialiser) + if (!null_initialisation) { - set_error( - make_error(parser_error::e_syntax, - current_token(), - "ERR140 - Expected '{' as part of vector initialiser list")); + if (0 == initialiser) + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR140 - Expected '{' as part of vector initialiser list")); - return error_node(); + return error_node(); + } + else + vec_to_vec_initialiser = true; } - else - vec_to_vec_initialiser = true; } else if (!token_is(token_t::e_rcrlbracket)) { @@ -22385,7 +22427,9 @@ expression_node_ptr result = error_node(); - if (vec_to_vec_initialiser) + if (null_initialisation) + result = expression_generator_(T(0.0)); + else if (vec_to_vec_initialiser) result = expression_generator_( details::e_assign, node_allocator_.allocate<vector_node_t>(vec_holder), @@ -32912,6 +32956,8 @@ public: + using ifunction<T>::operator(); + polynomial() : ifunction<T>((N+2 <= 20) ? (N + 2) : std::numeric_limits<std::size_t>::max()) { @@ -33114,6 +33160,8 @@ typedef std::pair<T*,std::size_t> lvarref_t; typedef std::vector<lvarref_t> lvr_vec_t; + using exprtk::ifunction<T>::operator(); + base_func(const std::size_t& pc = 0) : exprtk::ifunction<T>(pc), local_var_stack_size(0), @@ -33165,7 +33213,8 @@ { expression = expr; - typedef typename expression_t::expression_holder::local_data_list_t ldl_t; + typedef typename expression_t::control_block::local_data_list_t ldl_t; + ldl_t ldl = expr.local_data_list(); std::vector<std::size_t> index_list; @@ -33318,6 +33367,8 @@ struct func_0param : public base_func { + using exprtk::ifunction<T>::operator(); + func_0param() : base_func(0) {} inline T operator()() @@ -33344,6 +33395,8 @@ struct func_1param : public base_func { + using exprtk::ifunction<T>::operator(); + func_1param() : base_func(1) {} inline T operator()(type v0) @@ -33358,6 +33411,8 @@ struct func_2param : public base_func { + using exprtk::ifunction<T>::operator(); + func_2param() : base_func(2) {} inline T operator()(type v0, type v1) @@ -33372,6 +33427,8 @@ struct func_3param : public base_func { + using exprtk::ifunction<T>::operator(); + func_3param() : base_func(3) {} inline T operator()(type v0, type v1, type v2) @@ -33386,6 +33443,8 @@ struct func_4param : public base_func { + using exprtk::ifunction<T>::operator(); + func_4param() : base_func(4) {} inline T operator()(type v0, type v1, type v2, type v3) @@ -33400,6 +33459,8 @@ struct func_5param : public base_func { + using exprtk::ifunction<T>::operator(); + func_5param() : base_func(5) {} inline T operator()(type v0, type v1, type v2, type v3, type v4) @@ -33414,6 +33475,8 @@ struct func_6param : public base_func { + using exprtk::ifunction<T>::operator(); + func_6param() : base_func(6) {} inline T operator()(type v0, type v1, type v2, type v3, type v4, type v5)
diff --git a/exprtk_test.cpp b/exprtk_test.cpp index 8878f5a..10dba03 100644 --- a/exprtk_test.cpp +++ b/exprtk_test.cpp
@@ -3193,6 +3193,8 @@ template <typename T> struct myfunc : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + myfunc() : exprtk::ifunction<T>(2) {} inline T operator()(const T& v1, const T& v2) @@ -4272,7 +4274,9 @@ "7 == (for (var i := 0; i < 10; i += 1) { ~{break[7]; continue; i += i} })", "0 == (for (var i := 0; i < 10; i += 1) { ~{break[i]; continue; i += i} })", "0 == (for (var i := 0; i < 10; i += 1) { ~{continue; break[7]; i += i} })", - "1 == (for (var i := 0; i < 10; i += 1) { ~{break[i += 1]; continue; i += i} })" + "1 == (for (var i := 0; i < 10; i += 1) { ~{break[i += 1]; continue; i += i} })", + + "var x[10^6] := null; var y[10^7] := null; 0 * (min(x) + min(y)) + x[] + y[] == 10^7 + 10^6" }; const std::size_t expression_list_size = sizeof(expression_list) / sizeof(std::string); @@ -4286,6 +4290,7 @@ symbol_table.add_variable("zero",zero); symbol_table.add_variable("one" , one); + symbol_table.add_pi(); bool failed = false; @@ -4548,6 +4553,8 @@ template <typename T> struct sine_deg : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + sine_deg() : exprtk::ifunction<T>(1) {} inline T operator()(const T& v) @@ -4559,6 +4566,8 @@ template <typename T> struct cosine_deg : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + cosine_deg() : exprtk::ifunction<T>(1) {} inline T operator()(const T& v) @@ -4945,6 +4954,8 @@ template <typename T> struct base_func : public exprtk::ifunction<T> { + using exprtk::ifunction<T>::operator(); + typedef const T& type; base_func(const std::size_t& n) : exprtk::ifunction<T>(n) {} inline T operator()(type v0, type v1, type v2, type v3, type v4) { return (v0 + v1 + v2 + v3 + v4); } @@ -5251,6 +5262,8 @@ typedef typename generic_type::vector_view vector_t; typedef typename generic_type::string_view string_t; + using exprtk::igeneric_function<T>::operator(); + gen_func() : scalar_count(0), vector_count(0), @@ -5301,10 +5314,12 @@ { typedef typename exprtk::igeneric_function<T>::parameter_list_t parameter_list_t; + using exprtk::igeneric_function<T>::operator(); + gen_func2() {} - inline T operator()(parameter_list_t&) + inline T operator()(parameter_list_t) { return T(0); } @@ -5325,6 +5340,8 @@ typedef typename generic_type::vector_view vector_t; typedef typename generic_type::string_view string_t; + using exprtk::igeneric_function<T>::operator(); + inc_func() {} @@ -5383,6 +5400,8 @@ typedef typename igenfunc_t::parameter_list_t parameter_list_t; typedef typename generic_type::string_view string_t; + using exprtk::igeneric_function<T>::operator(); + rem_space_and_uppercase() : igenfunc_t("S",igenfunc_t::e_rtrn_string) {} @@ -5426,6 +5445,8 @@ typedef typename generic_type::scalar_view scalar_t; typedef typename generic_type::vector_view vector_t; + using exprtk::igeneric_function<T>::operator(); + vararg_func() : exprtk::igeneric_function<T>("Z|T*|V") {} @@ -7022,6 +7043,47 @@ } } + { + symbol_table_t symbol_table; + + symbol_table.add_constants(); + + std::string expression_str[] = + { + "var delta := 10^-7; var total := 0; for (var i := 0; i <= 3; i += delta) { total += " + "erf(i) }; abs((delta * total) - (3 * erf(3) + (1 / exp(9) - 1) / sqrt(pi))) < 0.000001", + + "var delta := 10^-7; var total := 0; for (var i := 0; i <= 3; i += delta) { total += " + "erfc(i) }; abs((delta * total) - (3 * erfc(3) + ((1 - 1 / exp(9)) / sqrt(pi)))) < 0.000001" + }; + + expression_t e[2]; + + parser_t parser; + + for (std::size_t i = 0; i < 2; ++i) + { + e[i].register_symbol_table(symbol_table); + + if (!parser.compile(expression_str[i],e[i])) + { + printf("run_test19() - Error: %s Expression: %s\n", + parser.error().c_str(), + expression_str[i].c_str()); + + return false; + } + + if (T(1) != e[i].value()) + { + printf("run_test19() - erf/erfc computation error %d", + static_cast<unsigned int>(i)); + + return false; + } + } + } + return true; }
diff --git a/readme.txt b/readme.txt index 3a9d955..6d02b8c 100644 --- a/readme.txt +++ b/readme.txt
@@ -1174,10 +1174,13 @@ var x[3] := { 1, 2, 3 }; var y[5] := x; // 1, 2, 3, ??, ?? - (h) Error as there are too many initialisers + (h) Non-initialised vector + var x[3] := null; // ?? ?? ?? + + (i) Error as there are too many initialisers var x[3] := { 1, 2, 3, 4 }; - (i) Error as a vector of size zero is not allowed. + (j) Error as a vector of size zero is not allowed. var x[0]; @@ -2496,7 +2499,7 @@ produce the following output: Error: ERR184 - Undefined symbol: 'x' - Err No.:00 Pos:17 Type:[Syntax] Msg: ERR184 - Undefined symbol: 'x' + Error[00] Pos:17 Type:[Syntax] Msg: ERR184 - Undefined symbol: 'x' For expressions comprised of multiple lines, the error position