exprtk.hpp File Reference

#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <exception>
#include <functional>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include <ctime>
#include <sys/time.h>
#include <sys/types.h>
#include <fstream>

Include dependency graph for exprtk.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	exprtk::details::ilesscompare
class	exprtk::details::build_string
struct	exprtk::details::cs_match
struct	exprtk::details::cis_match
struct	exprtk::details::numeric::details::unknown_type_tag
struct	exprtk::details::numeric::details::real_type_tag
struct	exprtk::details::numeric::details::complex_type_tag
struct	exprtk::details::numeric::details::int_type_tag
struct	exprtk::details::numeric::details::number_type< T >
struct	exprtk::details::numeric::numeric_info< Type >
struct	exprtk::details::numeric::numeric_info< int >
struct	exprtk::details::numeric::numeric_info< float >
struct	exprtk::details::numeric::numeric_info< double >
struct	exprtk::details::numeric::numeric_info< long double >
struct	exprtk::details::numeric::fast_exp< T, N >
struct	exprtk::details::numeric::fast_exp< T, 10 >
struct	exprtk::details::numeric::fast_exp< T, 9 >
struct	exprtk::details::numeric::fast_exp< T, 8 >
struct	exprtk::details::numeric::fast_exp< T, 7 >
struct	exprtk::details::numeric::fast_exp< T, 6 >
struct	exprtk::details::numeric::fast_exp< T, 5 >
struct	exprtk::details::numeric::fast_exp< T, 4 >
struct	exprtk::details::numeric::fast_exp< T, 3 >
struct	exprtk::details::numeric::fast_exp< T, 2 >
struct	exprtk::details::numeric::fast_exp< T, 1 >
struct	exprtk::details::numeric::fast_exp< T, 0 >
struct	exprtk::details::functor_t< T >
struct	exprtk::loop_runtime_check
struct	exprtk::loop_runtime_check::violation_context
struct	exprtk::lexer::token
class	exprtk::lexer::generator
class	exprtk::lexer::helper_interface
class	exprtk::lexer::token_scanner
class	exprtk::lexer::token_modifier
class	exprtk::lexer::token_inserter
class	exprtk::lexer::token_joiner
class	exprtk::lexer::helper::commutative_inserter
class	exprtk::lexer::helper::operator_joiner
class	exprtk::lexer::helper::bracket_checker
class	exprtk::lexer::helper::numeric_checker
class	exprtk::lexer::helper::symbol_replacer
class	exprtk::lexer::helper::sequence_validator
class	exprtk::lexer::helper::sequence_validator_3tokens
struct	exprtk::lexer::helper::helper_assembly
class	exprtk::lexer::parser_helper
class	exprtk::vector_view< T >
struct	exprtk::type_store< T >
class	exprtk::type_store< T >::parameter_list
struct	exprtk::type_store< T >::type_view< ViewType >
struct	exprtk::type_store< T >::scalar_view
class	exprtk::results_context< T >
struct	exprtk::details::base_operation_t
struct	exprtk::details::loop_unroll::details
class	exprtk::details::vec_data_store< T >
struct	exprtk::details::node_collector_interface< Node >
class	exprtk::details::expression_node< T >
class	exprtk::details::node_collection_destructor< Node >
struct	exprtk::details::node_depth_base< Node >
class	exprtk::details::vector_holder< Type >
class	exprtk::details::null_node< T >
class	exprtk::details::null_eq_node< T >
class	exprtk::details::literal_node< T >
class	exprtk::details::range_interface< T >
class	exprtk::details::string_base_node< T >
class	exprtk::details::string_literal_node< T >
class	exprtk::details::unary_node< T >
class	exprtk::details::binary_node< T >
class	exprtk::details::binary_ext_node< T, Operation >
class	exprtk::details::trinary_node< T >
class	exprtk::details::quaternary_node< T >
class	exprtk::details::conditional_node< T >
class	exprtk::details::cons_conditional_node< T >
class	exprtk::details::break_exception< T >
class	exprtk::details::continue_exception
class	exprtk::details::break_node< T >
class	exprtk::details::continue_node< T >
struct	exprtk::details::loop_runtime_checker
class	exprtk::details::while_loop_node< T >
class	exprtk::details::repeat_until_loop_node< T >
class	exprtk::details::for_loop_node< T >
class	exprtk::details::while_loop_bc_node< T >
class	exprtk::details::repeat_until_loop_bc_node< T >
class	exprtk::details::for_loop_bc_node< T >
class	exprtk::details::switch_node< T >
class	exprtk::details::switch_n_node< T, Switch_N >
class	exprtk::details::multi_switch_node< T >
class	exprtk::details::ivariable< T >
class	exprtk::details::variable_node< T >
struct	exprtk::details::range_pack< T >
struct	exprtk::details::range_data_type< T >
class	exprtk::details::vector_interface< T >
class	exprtk::details::vector_node< T >
class	exprtk::details::vector_elem_node< T >
class	exprtk::details::rebasevector_elem_node< T >
class	exprtk::details::rebasevector_celem_node< T >
class	exprtk::details::vector_assignment_node< T >
class	exprtk::details::swap_node< T >
class	exprtk::details::swap_generic_node< T >
class	exprtk::details::swap_vecvec_node< T >
class	exprtk::details::stringvar_node< T >
class	exprtk::details::string_range_node< T >
class	exprtk::details::const_string_range_node< T >
class	exprtk::details::generic_string_range_node< T >
class	exprtk::details::string_concat_node< T >
class	exprtk::details::swap_string_node< T >
class	exprtk::details::swap_genstrings_node< T >
class	exprtk::details::stringvar_size_node< T >
class	exprtk::details::string_size_node< T >
struct	exprtk::details::asn_assignment
struct	exprtk::details::asn_addassignment
class	exprtk::details::assignment_string_node< T, AssignmentProcess >
class	exprtk::details::assignment_string_range_node< T, AssignmentProcess >
class	exprtk::details::conditional_string_node< T >
class	exprtk::details::cons_conditional_str_node< T >
class	exprtk::details::str_vararg_node< T, VarArgFunction >
struct	exprtk::details::sf_base< T >
class	exprtk::details::sf4_node< T, SpecialFunction >
class	exprtk::details::sf3_var_node< T, SpecialFunction >
class	exprtk::details::sf4_var_node< T, SpecialFunction >
class	exprtk::details::vararg_node< T, VarArgFunction >
class	exprtk::details::vararg_varnode< T, VarArgFunction >
class	exprtk::details::vectorize_node< T, VecFunction >
class	exprtk::details::assignment_node< T >
class	exprtk::details::assignment_vec_elem_node< T >
class	exprtk::details::assignment_rebasevec_elem_node< T >
class	exprtk::details::assignment_rebasevec_celem_node< T >
class	exprtk::details::assignment_vec_node< T >
class	exprtk::details::assignment_vecvec_node< T >
class	exprtk::details::assignment_op_node< T, Operation >
class	exprtk::details::assignment_vec_elem_op_node< T, Operation >
class	exprtk::details::assignment_rebasevec_elem_op_node< T, Operation >
class	exprtk::details::assignment_rebasevec_celem_op_node< T, Operation >
class	exprtk::details::assignment_vec_op_node< T, Operation >
class	exprtk::details::assignment_vecvec_op_node< T, Operation >
class	exprtk::details::vec_binop_vecvec_node< T, Operation >
class	exprtk::details::vec_binop_vecval_node< T, Operation >
class	exprtk::details::vec_binop_valvec_node< T, Operation >
class	exprtk::details::unary_vector_node< T, Operation >
class	exprtk::details::scand_node< T >
class	exprtk::details::scor_node< T >
class	exprtk::details::function_N_node< T, IFunction, N >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, BranchCount >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 5 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 4 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 3 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 2 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 1 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, ParamCount >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 20 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 19 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 18 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 17 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 16 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 15 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 14 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 13 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 12 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 11 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 10 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 9 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 8 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 7 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 6 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 5 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 4 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 3 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 2 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 1 >
class	exprtk::details::function_N_node< T, IFunction, 0 >
class	exprtk::details::vararg_function_node< T, VarArgFunction >
class	exprtk::details::generic_function_node< T, GenericFunction >
class	exprtk::details::string_function_node< T, StringFunction >
class	exprtk::details::multimode_genfunction_node< T, GenericFunction >
class	exprtk::details::multimode_strfunction_node< T, StringFunction >
class	exprtk::details::return_exception
class	exprtk::details::null_igenfunc< T >
class	exprtk::details::return_node< T >
class	exprtk::details::return_envelope_node< T >
struct	exprtk::details::add_op< T >
struct	exprtk::details::mul_op< T >
struct	exprtk::details::sub_op< T >
struct	exprtk::details::div_op< T >
struct	exprtk::details::mod_op< T >
struct	exprtk::details::pow_op< T >
struct	exprtk::details::lt_op< T >
struct	exprtk::details::lte_op< T >
struct	exprtk::details::gt_op< T >
struct	exprtk::details::gte_op< T >
struct	exprtk::details::eq_op< T >
struct	exprtk::details::equal_op< T >
struct	exprtk::details::ne_op< T >
struct	exprtk::details::and_op< T >
struct	exprtk::details::nand_op< T >
struct	exprtk::details::or_op< T >
struct	exprtk::details::nor_op< T >
struct	exprtk::details::xor_op< T >
struct	exprtk::details::xnor_op< T >
struct	exprtk::details::in_op< T >
struct	exprtk::details::like_op< T >
struct	exprtk::details::ilike_op< T >
struct	exprtk::details::inrange_op< T >
struct	exprtk::details::vararg_add_op< T >
struct	exprtk::details::vararg_mul_op< T >
struct	exprtk::details::vararg_avg_op< T >
struct	exprtk::details::vararg_min_op< T >
struct	exprtk::details::vararg_max_op< T >
struct	exprtk::details::vararg_mand_op< T >
struct	exprtk::details::vararg_mor_op< T >
struct	exprtk::details::vararg_multi_op< T >
struct	exprtk::details::vec_add_op< T >
struct	exprtk::details::vec_mul_op< T >
struct	exprtk::details::vec_avg_op< T >
struct	exprtk::details::vec_min_op< T >
struct	exprtk::details::vec_max_op< T >
class	exprtk::details::vov_base_node< T >
class	exprtk::details::cov_base_node< T >
class	exprtk::details::voc_base_node< T >
class	exprtk::details::vob_base_node< T >
class	exprtk::details::bov_base_node< T >
class	exprtk::details::cob_base_node< T >
class	exprtk::details::boc_base_node< T >
class	exprtk::details::uv_base_node< T >
class	exprtk::details::sos_base_node< T >
class	exprtk::details::sosos_base_node< T >
class	exprtk::details::T0oT1oT2_base_node< T >
class	exprtk::details::T0oT1oT2oT3_base_node< T >
class	exprtk::details::unary_variable_node< T, Operation >
class	exprtk::details::uvouv_node< T >
class	exprtk::details::unary_branch_node< T, Operation >
struct	exprtk::details::is_const< T >
struct	exprtk::details::is_const< const T >
struct	exprtk::details::is_const_ref< T >
struct	exprtk::details::is_const_ref< const T & >
struct	exprtk::details::is_ref< T >
struct	exprtk::details::is_ref< T & >
struct	exprtk::details::is_ref< const T & >
struct	exprtk::details::param_to_str< State >
struct	exprtk::details::param_to_str< 0 >
struct	exprtk::details::T0oT1oT2process< T >
struct	exprtk::details::T0oT1oT2process< T >::mode0
struct	exprtk::details::T0oT1oT2process< T >::mode1
struct	exprtk::details::T0oT1oT20T3process< T >
struct	exprtk::details::T0oT1oT20T3process< T >::mode0
struct	exprtk::details::T0oT1oT20T3process< T >::mode1
struct	exprtk::details::T0oT1oT20T3process< T >::mode2
struct	exprtk::details::T0oT1oT20T3process< T >::mode3
struct	exprtk::details::T0oT1oT20T3process< T >::mode4
struct	exprtk::details::nodetype_T0oT1< T, T0, T1 >
struct	exprtk::details::nodetype_T0oT1oT2
struct	exprtk::details::nodetype_T0oT1oT2oT3
class	exprtk::details::T0oT1< T, T0, T1 >
class	exprtk::details::T0oT1oT2< T, T0, T1, T2, ProcessMode >
class	exprtk::details::T0oT1oT2oT3< T, T0_, T1_, T2_, T3_, ProcessMode >
class	exprtk::details::T0oT1oT2_sf3< T, T0, T1, T2 >
class	exprtk::details::sf3ext_type_node< T, T0, T1, T2 >
class	exprtk::details::T0oT1oT2_sf3ext< T, T0, T1, T2, SF3Operation >
class	exprtk::details::T0oT1oT2oT3_sf4< T, T0, T1, T2, T3 >
class	exprtk::details::T0oT1oT2oT3_sf4ext< T, T0, T1, T2, T3, SF4Operation >
struct	exprtk::details::T0oT1_define< T, T0, T1 >
struct	exprtk::details::T0oT1oT2_define< T, T0, T1, T2 >
struct	exprtk::details::T0oT1oT2oT3_define< T, T0, T1, T2, T3 >
class	exprtk::details::vov_node< T, Operation >
class	exprtk::details::cov_node< T, Operation >
class	exprtk::details::voc_node< T, Operation >
class	exprtk::details::vob_node< T, Operation >
class	exprtk::details::bov_node< T, Operation >
class	exprtk::details::cob_node< T, Operation >
class	exprtk::details::boc_node< T, Operation >
class	exprtk::details::sos_node< T, SType0, SType1, Operation >
class	exprtk::details::str_xrox_node< T, SType0, SType1, RangePack, Operation >
class	exprtk::details::str_xoxr_node< T, SType0, SType1, RangePack, Operation >
class	exprtk::details::str_xroxr_node< T, SType0, SType1, RangePack, Operation >
class	exprtk::details::str_sogens_node< T, Operation >
class	exprtk::details::sosos_node< T, SType0, SType1, SType2, Operation >
class	exprtk::details::ipow_node< T, PowOp >
class	exprtk::details::bipow_node< T, PowOp >
class	exprtk::details::ipowinv_node< T, PowOp >
class	exprtk::details::bipowninv_node< T, PowOp >
class	exprtk::details::node_allocator
class	exprtk::function_traits
class	exprtk::ifunction< T >
class	exprtk::ivararg_function< T >
class	exprtk::igeneric_function< T >
class	exprtk::symbol_table< T >
struct	exprtk::symbol_table< T >::freefunc00
struct	exprtk::symbol_table< T >::freefunc01
struct	exprtk::symbol_table< T >::freefunc02
struct	exprtk::symbol_table< T >::freefunc03
struct	exprtk::symbol_table< T >::freefunc04
struct	exprtk::symbol_table< T >::freefunc05
struct	exprtk::symbol_table< T >::freefunc06
struct	exprtk::symbol_table< T >::freefunc07
struct	exprtk::symbol_table< T >::freefunc08
struct	exprtk::symbol_table< T >::freefunc09
struct	exprtk::symbol_table< T >::freefunc10
struct	exprtk::symbol_table< T >::freefunc11
struct	exprtk::symbol_table< T >::freefunc12
struct	exprtk::symbol_table< T >::freefunc13
struct	exprtk::symbol_table< T >::freefunc14
struct	exprtk::symbol_table< T >::freefunc15
struct	exprtk::symbol_table< T >::type_store< Type, RawType >
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::deleter
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_array
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_stdvec
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_vecview
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_stddeq
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::ptr_match< TType, TRawType, PtrType >
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::ptr_match< TType, TRawType, variable_node_t * >
struct	exprtk::symbol_table< T >::control_block
struct	exprtk::symbol_table< T >::control_block::st_data
class	exprtk::expression< T >
struct	exprtk::expression< T >::control_block::data_pack
class	exprtk::expression_helper< T >
struct	exprtk::parser_error::type
class	exprtk::parser< T >
struct	exprtk::parser< T >::unknown_symbol_resolver
class	exprtk::parser< T >::dependent_entity_collector
class	exprtk::parser< T >::settings_store
struct	exprtk::parser< T >::type_checker::function_prototype_t
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_1
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_2
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_3
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_4
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_5
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_6
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_7
struct	exprtk::details::collector_helper< T >
struct	exprtk::details::collector_helper< T >::resolve_as_vector
class	exprtk::polynomial< T, N >
class	exprtk::function_compositor< T >
struct	exprtk::function_compositor< T >::function
class	exprtk::timer
struct	exprtk::rtl::io::details::print_impl< T >
struct	exprtk::rtl::io::print< T >
struct	exprtk::rtl::io::println< T >
struct	exprtk::rtl::io::package< T >
struct	exprtk::rtl::io::file::details::file_descriptor
class	exprtk::rtl::io::file::open< T >
struct	exprtk::rtl::io::file::close< T >
class	exprtk::rtl::io::file::write< T >
class	exprtk::rtl::io::file::read< T >
class	exprtk::rtl::io::file::getline< T >
struct	exprtk::rtl::io::file::eof< T >
struct	exprtk::rtl::io::file::package< T >
struct	exprtk::rtl::vecops::helper::load_vector_range< T >
class	exprtk::rtl::vecops::all_true< T >
class	exprtk::rtl::vecops::all_false< T >
class	exprtk::rtl::vecops::any_true< T >
class	exprtk::rtl::vecops::any_false< T >
class	exprtk::rtl::vecops::count< T >
class	exprtk::rtl::vecops::copy< T >
class	exprtk::rtl::vecops::rol< T >
class	exprtk::rtl::vecops::ror< T >
class	exprtk::rtl::vecops::shift_left< T >
class	exprtk::rtl::vecops::shift_right< T >
class	exprtk::rtl::vecops::sort< T >
class	exprtk::rtl::vecops::nthelement< T >
class	exprtk::rtl::vecops::iota< T >
class	exprtk::rtl::vecops::sumk< T >
class	exprtk::rtl::vecops::axpy< T >
class	exprtk::rtl::vecops::axpby< T >
class	exprtk::rtl::vecops::axpyz< T >
class	exprtk::rtl::vecops::axpbyz< T >
class	exprtk::rtl::vecops::axpbz< T >
class	exprtk::rtl::vecops::dot< T >
class	exprtk::rtl::vecops::dotk< T >
struct	exprtk::rtl::vecops::package< T >

Namespaces
namespace	exprtk
namespace	exprtk::details
namespace	exprtk::details::numeric
namespace	exprtk::details::numeric::constant
namespace	exprtk::details::numeric::details
namespace	exprtk::lexer
namespace	exprtk::lexer::helper
namespace	exprtk::details::loop_unroll
namespace	exprtk::parser_error
namespace	exprtk::rtl
namespace	exprtk::rtl::io
namespace	exprtk::rtl::io::details
namespace	exprtk::rtl::io::file
namespace	exprtk::rtl::io::file::details
namespace	exprtk::rtl::vecops
namespace	exprtk::rtl::vecops::helper
namespace	exprtk::rtl::vecops::details
namespace	exprtk::information

Macros
#define	exprtk_debug(params)   (void)0
#define	exprtk_error_location    "exprtk.hpp:" + details::to_str(__LINE__) \
#define	exprtk_disable_fallthrough_begin   (void)0;
#define	exprtk_disable_fallthrough_end   (void)0;
#define	exprtk_register_real_type_tag(T)
#define	exprtk_register_complex_type_tag(T)
#define	exprtk_register_int_type_tag(T)
#define	exprtk_define_epsilon_type(Type, Epsilon)
#define	exprtk_define_erf(TT, impl)    inline TT erf_impl(TT v) { return impl(v); } \
#define	exprtk_define_erfc(TT, impl)    inline TT erfc_impl(TT v) { return impl(v); } \
#define	exprtk_define_unary_function(FunctionName)
#define	exprtk_process_digit
#define	parse_digit_1(d)
#define	parse_digit_2(d)
#define	token_inserter_empty_body
#define	exprtk_loop(N)    std::swap(s0[N], s1[N]); \
#define	case_stmt(N)    case N : { std::swap(s0[i], s1[i]); ++i; } \
#define	define_sfop3(NN, OP0, OP1)
#define	define_sfop4(NN, OP0, OP1)
#define	exprtk_loop(N)    vec[N] = v; \
#define	case_stmt(N)    case N : *vec++ = v; \
#define	exprtk_loop(N)    vec0[N] = vec1[N]; \
#define	case_stmt(N)    case N : *vec0++ = *vec1++; \
#define	exprtk_loop(N)    Operation::assign(vec[N],v); \
#define	case_stmt(N)    case N : Operation::assign(*vec++,v); \
#define	exprtk_loop(N)    vec0[N] = Operation::process(vec0[N], vec1[N]); \
#define	case_stmt(N)    case N : { vec0[i] = Operation::process(vec0[i], vec1[i]); ++i; } \
#define	exprtk_loop(N)    vec2[N] = Operation::process(vec0[N], vec1[N]); \
#define	case_stmt(N)    case N : { vec2[i] = Operation::process(vec0[i], vec1[i]); ++i; } \
#define	exprtk_loop(N)    vec1[N] = Operation::process(vec0[N], v); \
#define	case_stmt(N)    case N : { vec1[i] = Operation::process(vec0[i], v); ++i; } \
#define	exprtk_loop(N)    vec0[N] = Operation::process(v, vec1[N]); \
#define	case_stmt(N)    case N : { vec0[i] = Operation::process(v, vec1[i]); ++i; } \
#define	exprtk_loop(N)    vec1[N] = Operation::process(vec0[N]); \
#define	case_stmt(N)    case N : { vec1[i] = Operation::process(vec0[i]); ++i; } \
#define	exprtk_define_unary_op(OpName)
#define	case_stmt(N)    case N : result += vec[i++]; \
#define	exprtk_loop(N)    r[N] += vec[N]; \
#define	case_stmt(N)    case N : r[0] += vec[i++]; \
#define	case_stmt(N)    case N : result *= vec[i++]; \
#define	exprtk_loop(N)    r[N] *= vec[N]; \
#define	case_stmt(N)    case N : r[0] *= vec[i++]; \
#define	exprtk_crtype(Type)    param_to_str<is_const_ref< Type >::result>::result() \
#define	synthesis_node_type_define(T0_, T1_, v_)
#define	synthesis_node_type_define(T0_, T1_, T2_, v_)
#define	synthesis_node_type_define(T0_, T1_, T2_, T3_, v_)
#define	register_op(Symbol, Type, Args)    m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \
#define	empty_method_body(N)
#define	igeneric_function_empty_body(N)
#define	exprtk_define_process(Type)
#define	exprtk_define_freefunction(NN)
#define	base_opr_case(N)
#define	register_synthezier(S)    synthesize_map_[S ::node_type::id()] = S ::process; \
#define	case_stmt(N)    if (is_true(arg[(2 * N)].first)) { return arg[(2 * N) + 1].first->value(); } \
#define	case_stmt(N)
#define	unary_opr_switch_statements
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	batch_eqineq_logic_case
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	vector_ops
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	basic_opr_switch_statements
#define	extended_opr_switch_statements
#define	case_stmt(cp)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op)
#define	case_stmt0(op)
#define	case_stmt1(op)
#define	string_opr_switch_statements
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	register_unary_op(Op, UnaryFunctor)    m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \
#define	register_binary_op(Op, BinaryFunctor)    m.insert(value_type(Op,BinaryFunctor<T>::process)); \
#define	register_binary_op(Op, BinaryFunctor)    m.insert(value_type(BinaryFunctor<T>::process,Op)); \
#define	register_sf3(Op)    sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
#define	register_sf3_extid(Id, Op)    sf3_map[Id] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
#define	register_sf4(Op)    sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
#define	register_sf4ext(Op)    sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \
#define	poly_rtrn(NN)    return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :
#define	def_fp_retval(N)
#define	case_stmt(N)
#define	else_stmt(N)
#define	exprtk_register_function(FunctionName, FunctionType)
#define	exprtk_register_function(FunctionName, FunctionType)
#define	exprtk_register_function(FunctionName, FunctionType)

Typedefs
typedef unsigned char	exprtk::details::uchar_t
typedef char	exprtk::details::char_t
typedef uchar_t *	exprtk::details::uchar_ptr
typedef char_t *	exprtk::details::char_ptr
typedef uchar_t const *	exprtk::details::uchar_cptr
typedef char_t const *	exprtk::details::char_cptr
typedef unsigned long long int	exprtk::details::_uint64_t
typedef long long int	exprtk::details::_int64_t
typedef loop_runtime_check *	exprtk::loop_runtime_check_ptr

Enumerations
enum	exprtk::details::operator_type {   exprtk::details::e_default , exprtk::details::e_null , exprtk::details::e_add , exprtk::details::e_sub ,   exprtk::details::e_mul , exprtk::details::e_div , exprtk::details::e_mod , exprtk::details::e_pow ,   exprtk::details::e_atan2 , exprtk::details::e_min , exprtk::details::e_max , exprtk::details::e_avg ,   exprtk::details::e_sum , exprtk::details::e_prod , exprtk::details::e_lt , exprtk::details::e_lte ,   exprtk::details::e_eq , exprtk::details::e_equal , exprtk::details::e_ne , exprtk::details::e_nequal ,   exprtk::details::e_gte , exprtk::details::e_gt , exprtk::details::e_and , exprtk::details::e_nand ,   exprtk::details::e_or , exprtk::details::e_nor , exprtk::details::e_xor , exprtk::details::e_xnor ,   exprtk::details::e_mand , exprtk::details::e_mor , exprtk::details::e_scand , exprtk::details::e_scor ,   exprtk::details::e_shr , exprtk::details::e_shl , exprtk::details::e_abs , exprtk::details::e_acos ,   exprtk::details::e_acosh , exprtk::details::e_asin , exprtk::details::e_asinh , exprtk::details::e_atan ,   exprtk::details::e_atanh , exprtk::details::e_ceil , exprtk::details::e_cos , exprtk::details::e_cosh ,   exprtk::details::e_exp , exprtk::details::e_expm1 , exprtk::details::e_floor , exprtk::details::e_log ,   exprtk::details::e_log10 , exprtk::details::e_log2 , exprtk::details::e_log1p , exprtk::details::e_logn ,   exprtk::details::e_neg , exprtk::details::e_pos , exprtk::details::e_round , exprtk::details::e_roundn ,   exprtk::details::e_root , exprtk::details::e_sqrt , exprtk::details::e_sin , exprtk::details::e_sinc ,   exprtk::details::e_sinh , exprtk::details::e_sec , exprtk::details::e_csc , exprtk::details::e_tan ,   exprtk::details::e_tanh , exprtk::details::e_cot , exprtk::details::e_clamp , exprtk::details::e_iclamp ,   exprtk::details::e_inrange , exprtk::details::e_sgn , exprtk::details::e_r2d , exprtk::details::e_d2r ,   exprtk::details::e_d2g , exprtk::details::e_g2d , exprtk::details::e_hypot , exprtk::details::e_notl ,   exprtk::details::e_erf , exprtk::details::e_erfc , exprtk::details::e_ncdf , exprtk::details::e_frac ,   exprtk::details::e_trunc , exprtk::details::e_assign , exprtk::details::e_addass , exprtk::details::e_subass ,   exprtk::details::e_mulass , exprtk::details::e_divass , exprtk::details::e_modass , exprtk::details::e_in ,   exprtk::details::e_like , exprtk::details::e_ilike , exprtk::details::e_multi , exprtk::details::e_smulti ,   exprtk::details::e_swap , exprtk::details::e_sf00 = 1000 , exprtk::details::e_sf01 = 1001 , exprtk::details::e_sf02 = 1002 ,   exprtk::details::e_sf03 = 1003 , exprtk::details::e_sf04 = 1004 , exprtk::details::e_sf05 = 1005 , exprtk::details::e_sf06 = 1006 ,   exprtk::details::e_sf07 = 1007 , exprtk::details::e_sf08 = 1008 , exprtk::details::e_sf09 = 1009 , exprtk::details::e_sf10 = 1010 ,   exprtk::details::e_sf11 = 1011 , exprtk::details::e_sf12 = 1012 , exprtk::details::e_sf13 = 1013 , exprtk::details::e_sf14 = 1014 ,   exprtk::details::e_sf15 = 1015 , exprtk::details::e_sf16 = 1016 , exprtk::details::e_sf17 = 1017 , exprtk::details::e_sf18 = 1018 ,   exprtk::details::e_sf19 = 1019 , exprtk::details::e_sf20 = 1020 , exprtk::details::e_sf21 = 1021 , exprtk::details::e_sf22 = 1022 ,   exprtk::details::e_sf23 = 1023 , exprtk::details::e_sf24 = 1024 , exprtk::details::e_sf25 = 1025 , exprtk::details::e_sf26 = 1026 ,   exprtk::details::e_sf27 = 1027 , exprtk::details::e_sf28 = 1028 , exprtk::details::e_sf29 = 1029 , exprtk::details::e_sf30 = 1030 ,   exprtk::details::e_sf31 = 1031 , exprtk::details::e_sf32 = 1032 , exprtk::details::e_sf33 = 1033 , exprtk::details::e_sf34 = 1034 ,   exprtk::details::e_sf35 = 1035 , exprtk::details::e_sf36 = 1036 , exprtk::details::e_sf37 = 1037 , exprtk::details::e_sf38 = 1038 ,   exprtk::details::e_sf39 = 1039 , exprtk::details::e_sf40 = 1040 , exprtk::details::e_sf41 = 1041 , exprtk::details::e_sf42 = 1042 ,   exprtk::details::e_sf43 = 1043 , exprtk::details::e_sf44 = 1044 , exprtk::details::e_sf45 = 1045 , exprtk::details::e_sf46 = 1046 ,   exprtk::details::e_sf47 = 1047 , exprtk::details::e_sf48 = 1048 , exprtk::details::e_sf49 = 1049 , exprtk::details::e_sf50 = 1050 ,   exprtk::details::e_sf51 = 1051 , exprtk::details::e_sf52 = 1052 , exprtk::details::e_sf53 = 1053 , exprtk::details::e_sf54 = 1054 ,   exprtk::details::e_sf55 = 1055 , exprtk::details::e_sf56 = 1056 , exprtk::details::e_sf57 = 1057 , exprtk::details::e_sf58 = 1058 ,   exprtk::details::e_sf59 = 1059 , exprtk::details::e_sf60 = 1060 , exprtk::details::e_sf61 = 1061 , exprtk::details::e_sf62 = 1062 ,   exprtk::details::e_sf63 = 1063 , exprtk::details::e_sf64 = 1064 , exprtk::details::e_sf65 = 1065 , exprtk::details::e_sf66 = 1066 ,   exprtk::details::e_sf67 = 1067 , exprtk::details::e_sf68 = 1068 , exprtk::details::e_sf69 = 1069 , exprtk::details::e_sf70 = 1070 ,   exprtk::details::e_sf71 = 1071 , exprtk::details::e_sf72 = 1072 , exprtk::details::e_sf73 = 1073 , exprtk::details::e_sf74 = 1074 ,   exprtk::details::e_sf75 = 1075 , exprtk::details::e_sf76 = 1076 , exprtk::details::e_sf77 = 1077 , exprtk::details::e_sf78 = 1078 ,   exprtk::details::e_sf79 = 1079 , exprtk::details::e_sf80 = 1080 , exprtk::details::e_sf81 = 1081 , exprtk::details::e_sf82 = 1082 ,   exprtk::details::e_sf83 = 1083 , exprtk::details::e_sf84 = 1084 , exprtk::details::e_sf85 = 1085 , exprtk::details::e_sf86 = 1086 ,   exprtk::details::e_sf87 = 1087 , exprtk::details::e_sf88 = 1088 , exprtk::details::e_sf89 = 1089 , exprtk::details::e_sf90 = 1090 ,   exprtk::details::e_sf91 = 1091 , exprtk::details::e_sf92 = 1092 , exprtk::details::e_sf93 = 1093 , exprtk::details::e_sf94 = 1094 ,   exprtk::details::e_sf95 = 1095 , exprtk::details::e_sf96 = 1096 , exprtk::details::e_sf97 = 1097 , exprtk::details::e_sf98 = 1098 ,   exprtk::details::e_sf99 = 1099 , exprtk::details::e_sffinal = 1100 , exprtk::details::e_sf4ext00 = 2000 , exprtk::details::e_sf4ext01 = 2001 ,   exprtk::details::e_sf4ext02 = 2002 , exprtk::details::e_sf4ext03 = 2003 , exprtk::details::e_sf4ext04 = 2004 , exprtk::details::e_sf4ext05 = 2005 ,   exprtk::details::e_sf4ext06 = 2006 , exprtk::details::e_sf4ext07 = 2007 , exprtk::details::e_sf4ext08 = 2008 , exprtk::details::e_sf4ext09 = 2009 ,   exprtk::details::e_sf4ext10 = 2010 , exprtk::details::e_sf4ext11 = 2011 , exprtk::details::e_sf4ext12 = 2012 , exprtk::details::e_sf4ext13 = 2013 ,   exprtk::details::e_sf4ext14 = 2014 , exprtk::details::e_sf4ext15 = 2015 , exprtk::details::e_sf4ext16 = 2016 , exprtk::details::e_sf4ext17 = 2017 ,   exprtk::details::e_sf4ext18 = 2018 , exprtk::details::e_sf4ext19 = 2019 , exprtk::details::e_sf4ext20 = 2020 , exprtk::details::e_sf4ext21 = 2021 ,   exprtk::details::e_sf4ext22 = 2022 , exprtk::details::e_sf4ext23 = 2023 , exprtk::details::e_sf4ext24 = 2024 , exprtk::details::e_sf4ext25 = 2025 ,   exprtk::details::e_sf4ext26 = 2026 , exprtk::details::e_sf4ext27 = 2027 , exprtk::details::e_sf4ext28 = 2028 , exprtk::details::e_sf4ext29 = 2029 ,   exprtk::details::e_sf4ext30 = 2030 , exprtk::details::e_sf4ext31 = 2031 , exprtk::details::e_sf4ext32 = 2032 , exprtk::details::e_sf4ext33 = 2033 ,   exprtk::details::e_sf4ext34 = 2034 , exprtk::details::e_sf4ext35 = 2035 , exprtk::details::e_sf4ext36 = 2036 , exprtk::details::e_sf4ext37 = 2037 ,   exprtk::details::e_sf4ext38 = 2038 , exprtk::details::e_sf4ext39 = 2039 , exprtk::details::e_sf4ext40 = 2040 , exprtk::details::e_sf4ext41 = 2041 ,   exprtk::details::e_sf4ext42 = 2042 , exprtk::details::e_sf4ext43 = 2043 , exprtk::details::e_sf4ext44 = 2044 , exprtk::details::e_sf4ext45 = 2045 ,   exprtk::details::e_sf4ext46 = 2046 , exprtk::details::e_sf4ext47 = 2047 , exprtk::details::e_sf4ext48 = 2048 , exprtk::details::e_sf4ext49 = 2049 ,   exprtk::details::e_sf4ext50 = 2050 , exprtk::details::e_sf4ext51 = 2051 , exprtk::details::e_sf4ext52 = 2052 , exprtk::details::e_sf4ext53 = 2053 ,   exprtk::details::e_sf4ext54 = 2054 , exprtk::details::e_sf4ext55 = 2055 , exprtk::details::e_sf4ext56 = 2056 , exprtk::details::e_sf4ext57 = 2057 ,   exprtk::details::e_sf4ext58 = 2058 , exprtk::details::e_sf4ext59 = 2059 , exprtk::details::e_sf4ext60 = 2060 , exprtk::details::e_sf4ext61 = 2061 }
enum	exprtk::parser_error::error_mode {   exprtk::parser_error::e_unknown = 0 , exprtk::parser_error::e_syntax = 1 , exprtk::parser_error::e_token = 2 , exprtk::parser_error::e_numeric = 4 ,   exprtk::parser_error::e_symtab = 5 , exprtk::parser_error::e_lexer = 6 , exprtk::parser_error::e_helper = 7 , exprtk::parser_error::e_parser = 8 }
enum	exprtk::rtl::io::file::details::file_mode { exprtk::rtl::io::file::details::e_error = 0 , exprtk::rtl::io::file::details::e_read = 1 , exprtk::rtl::io::file::details::e_write = 2 , exprtk::rtl::io::file::details::e_rdwrt = 4 }

Functions
bool	exprtk::details::is_whitespace (const char_t c)
bool	exprtk::details::is_operator_char (const char_t c)
bool	exprtk::details::is_letter (const char_t c)
bool	exprtk::details::is_digit (const char_t c)
bool	exprtk::details::is_letter_or_digit (const char_t c)
bool	exprtk::details::is_left_bracket (const char_t c)
bool	exprtk::details::is_right_bracket (const char_t c)
bool	exprtk::details::is_bracket (const char_t c)
bool	exprtk::details::is_sign (const char_t c)
bool	exprtk::details::is_invalid (const char_t c)
bool	exprtk::details::is_valid_string_char (const char_t c)
void	exprtk::details::case_normalise (std::string &s)
bool	exprtk::details::imatch (const char_t c1, const char_t c2)
bool	exprtk::details::imatch (const std::string &s1, const std::string &s2)
bool	exprtk::details::is_valid_sf_symbol (const std::string &symbol)
const char_t &	exprtk::details::front (const std::string &s)
const char_t &	exprtk::details::back (const std::string &s)
std::string	exprtk::details::to_str (int i)
std::string	exprtk::details::to_str (std::size_t i)
bool	exprtk::details::is_hex_digit (const std::string::value_type digit)
uchar_t	exprtk::details::hex_to_bin (uchar_t h)
template<typename Iterator >
bool	exprtk::details::parse_hex (Iterator &itr, Iterator end, std::string::value_type &result)
bool	exprtk::details::cleanup_escapes (std::string &s)
bool	exprtk::details::is_reserved_word (const std::string &symbol)
bool	exprtk::details::is_reserved_symbol (const std::string &symbol)
bool	exprtk::details::is_base_function (const std::string &function_name)
bool	exprtk::details::is_control_struct (const std::string &cntrl_strct)
bool	exprtk::details::is_logic_opr (const std::string &lgc_opr)
template<typename Iterator , typename Compare >
bool	exprtk::details::match_impl (const Iterator pattern_begin, const Iterator pattern_end, const Iterator data_begin, const Iterator data_end, const typename std::iterator_traits< Iterator >::value_type &zero_or_more, const typename std::iterator_traits< Iterator >::value_type &zero_or_one)
bool	exprtk::details::wc_match (const std::string &wild_card, const std::string &str)
bool	exprtk::details::wc_imatch (const std::string &wild_card, const std::string &str)
bool	exprtk::details::sequence_match (const std::string &pattern, const std::string &str, std::size_t &diff_index, char_t &diff_value)
	exprtk::details::numeric::details::exprtk_register_real_type_tag (double) exprtk_register_real_type_tag(long double) exprtk_register_real_type_tag(float) exprtk_register_complex_type_tag(double) exprtk_register_complex_type_tag(long double) exprtk_register_complex_type_tag(float) exprtk_register_int_type_tag(short) exprtk_register_int_type_tag(int) exprtk_register_int_type_tag(_int64_t) exprtk_register_int_type_tag(unsigned short) exprtk_register_int_type_tag(unsigned int) exprtk_register_int_type_tag(_uint64_t) template< typename T > struct epsilon_type
	exprtk::details::numeric::details::exprtk_define_epsilon_type (float, 0.000001f) exprtk_define_epsilon_type(double
	exprtk::details::numeric::details::exprtk_define_epsilon_type (long double, 0.000000000001) template< typename T > inline bool is_nan_impl(const T v
template<typename T >
int	exprtk::details::numeric::details::to_int32_impl (const T v, real_type_tag)
template<typename T >
_int64_t	exprtk::details::numeric::details::to_int64_impl (const T v, real_type_tag)
template<typename T >
bool	exprtk::details::numeric::details::is_true_impl (const T v)
template<typename T >
bool	exprtk::details::numeric::details::is_false_impl (const T v)
template<typename T >
T	exprtk::details::numeric::details::abs_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::min_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::max_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::equal_impl (const T v0, const T v1, real_type_tag)
float	exprtk::details::numeric::details::equal_impl (const float v0, const float v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::equal_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::expm1_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::expm1_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nequal_impl (const T v0, const T v1, real_type_tag)
float	exprtk::details::numeric::details::nequal_impl (const float v0, const float v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nequal_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::modulus_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::modulus_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pow_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pow_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::logn_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::logn_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log1p_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log1p_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::root_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::root_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::round_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::roundn_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::roundn_impl (const T v0, const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::hypot_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::hypot_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan2_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan2_impl (const T, const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shr_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shr_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shl_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shl_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sgn_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sgn_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::and_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::and_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nand_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nand_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::or_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::or_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nor_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nor_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xor_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xor_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xnor_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xnor_impl (const T v0, const T v1, int_type_tag)
	exprtk::details::numeric::details::exprtk_define_erf (float,::erff) exprtk_define_erf(double
::erf	exprtk::details::numeric::details::exprtk_define_erf (long double,::erfl) template< typename T > inline T erf_impl(T v
template<typename T >
T	exprtk::details::numeric::details::erf_impl (T v, int_type_tag)
	exprtk::details::numeric::details::exprtk_define_erfc (float,::erfcf) exprtk_define_erfc(double
::erfc	exprtk::details::numeric::details::exprtk_define_erfc (long double,::erfcl) template< typename T > inline T erfc_impl(T v
template<typename T >
T	exprtk::details::numeric::details::erfc_impl (T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ncdf_impl (T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ncdf_impl (T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinc_impl (T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinc_impl (T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acos_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acosh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asin_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asinh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atanh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ceil_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cos_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cosh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::exp_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::floor_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log10_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log2_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::neg_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pos_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sin_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sqrt_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tan_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tanh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cot_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sec_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::csc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::r2d_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::d2r_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::d2g_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::g2d_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::notl_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::frac_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::trunc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::const_pi_impl (real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::const_e_impl (real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::abs_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::exp_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log10_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log2_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::neg_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pos_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ceil_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::floor_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::round_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::notl_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sqrt_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::frac_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::trunc_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acos_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acosh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asin_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asinh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atanh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cos_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cosh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sin_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tan_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tanh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cot_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sec_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::csc_impl (const T, int_type_tag)
template<typename T >
bool	exprtk::details::numeric::details::is_integer_impl (const T &v, real_type_tag)
template<typename T >
bool	exprtk::details::numeric::details::is_integer_impl (const T &, int_type_tag)
template<typename T >
int	exprtk::details::numeric::to_int32 (const T v)
template<typename T >
_int64_t	exprtk::details::numeric::to_int64 (const T v)
template<typename T >
bool	exprtk::details::numeric::is_nan (const T v)
template<typename T >
T	exprtk::details::numeric::min (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::max (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::equal (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::nequal (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::modulus (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::pow (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::logn (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::root (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::roundn (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::hypot (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::atan2 (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::shr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::shl (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::and_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::nand_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::or_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::nor_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::xor_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::xnor_opr (const T v0, const T v1)
template<typename T >
bool	exprtk::details::numeric::is_integer (const T v)
template<typename T >
T	exprtk::details::compute_pow10 (T d, const int exponent)
template<typename Iterator , typename T >
bool	exprtk::details::string_to_type_converter_impl_ref (Iterator &itr, const Iterator end, T &result)
template<typename Iterator , typename T >
static bool	exprtk::details::parse_nan (Iterator &itr, const Iterator end, T &t)
template<typename Iterator , typename T >
static bool	exprtk::details::parse_inf (Iterator &itr, const Iterator end, T &t, bool negative)
template<typename T >
bool	exprtk::details::valid_exponent (const int exponent, numeric::details::real_type_tag)
template<typename Iterator , typename T >
bool	exprtk::details::string_to_real (Iterator &itr_external, const Iterator end, T &t, numeric::details::real_type_tag)
template<typename T >
bool	exprtk::details::string_to_real (const std::string &s, T &t)
void	exprtk::lexer::helper::dump (const lexer::generator &generator)
template<typename T >
vector_view< T >	exprtk::make_vector_view (T *data, const std::size_t size, const std::size_t offset=0)
template<typename T >
vector_view< T >	exprtk::make_vector_view (std::vector< T > &v, const std::size_t size, const std::size_t offset=0)
template<typename StringView >
std::string	exprtk::to_str (const StringView &view)
std::string	exprtk::details::to_str (const operator_type opr)
void	exprtk::details::dump_ptr (const std::string &, const void *)
void	exprtk::details::dump_ptr (const std::string &, const void *, const std::size_t)
template<typename T >
T	exprtk::details::numeric::details::process_impl (const operator_type operation, const T arg)
template<typename T >
T	exprtk::details::numeric::details::process_impl (const operator_type operation, const T arg0, const T arg1)
template<typename T >
T	exprtk::details::numeric::details::process_impl (const operator_type operation, const T arg0, const T arg1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::process (const operator_type operation, const T arg)
template<typename T >
T	exprtk::details::numeric::process (const operator_type operation, const T arg0, const T arg1)
template<typename T >
bool	exprtk::details::is_generally_string_node (const expression_node< T > *node)
bool	exprtk::details::is_true (const double v)
bool	exprtk::details::is_true (const long double v)
bool	exprtk::details::is_true (const float v)
template<typename T >
bool	exprtk::details::is_true (const std::complex< T > &v)
template<typename T >
bool	exprtk::details::is_true (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_true (const std::pair< expression_node< T > *, bool > &node)
template<typename T >
bool	exprtk::details::is_false (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_false (const std::pair< expression_node< T > *, bool > &node)
template<typename T >
bool	exprtk::details::is_unary_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_neg_unary_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_binary_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_variable_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_ivariable_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_elem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_elem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_celem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_ivector_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_constant_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_null_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_break_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_continue_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_swap_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_function (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_return_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_negate_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::branch_deletable (expression_node< T > *node)
template<std::size_t N, typename T >
bool	exprtk::details::all_nodes_valid (expression_node< T > *(&b)[N])
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::details::all_nodes_valid (const Sequence< expression_node< T > *, Allocator > &b)
template<std::size_t N, typename T >
bool	exprtk::details::all_nodes_variables (expression_node< T > *(&b)[N])
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::details::all_nodes_variables (Sequence< expression_node< T > *, Allocator > &b)
template<typename NodeAllocator , typename T , std::size_t N>
void	exprtk::details::free_all_nodes (NodeAllocator &node_allocator, expression_node< T > *(&b)[N])
template<typename NodeAllocator , typename T , typename Allocator , template< typename, typename > class Sequence>
void	exprtk::details::free_all_nodes (NodeAllocator &node_allocator, Sequence< expression_node< T > *, Allocator > &b)
template<typename NodeAllocator , typename T >
void	exprtk::details::free_node (NodeAllocator &, expression_node< T > *&node)
template<typename T >
void	exprtk::details::destroy_node (expression_node< T > *&node)
template<typename T , std::size_t N>
void	exprtk::details::construct_branch_pair (std::pair< expression_node< T > *, bool >(&branch)[N], expression_node< T > *b, const std::size_t &index)
template<typename T >
void	exprtk::details::construct_branch_pair (std::pair< expression_node< T > *, bool > &branch, expression_node< T > *b)
template<std::size_t N, typename T >
void	exprtk::details::init_branches (std::pair< expression_node< T > *, bool >(&branch)[N], expression_node< T > *b0, expression_node< T > *b1=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b2=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b3=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b4=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b5=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b6=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b7=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b8=reinterpret_cast< expression_node< T > * >(0), expression_node< T > *b9=reinterpret_cast< expression_node< T > * >(0))
template<typename T , std::size_t N>
T	exprtk::details::axn (T a, T x)
template<typename T , std::size_t N>
T	exprtk::details::axnb (T a, T x, T b)
	exprtk::details::define_sfop3 (00,(x+y)/z,"(t+t)/t") define_sfop3(01
x y t t *t	exprtk::details::define_sfop3 (02,(x+y) - z,"(t+t)-t") define_sfop3(03
x y t t *t x y t t t	exprtk::details::define_sfop3 (04,(x - y)+z,"(t-t)+t") define_sfop3(05
x y t t *t x y t t t x y t t t	exprtk::details::define_sfop3 (06,(x - y) *z,"(t-t)*t") define_sfop3(07
x y t t *t x y t t t x y t t t x *y t *t t	exprtk::details::define_sfop3 (08,(x *y) - z,"(t*t)-t") define_sfop3(09
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t	exprtk::details::define_sfop3 (10,(x *y) *z,"(t*t)*t") define_sfop3(11
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t	exprtk::details::define_sfop3 (12,(x/y) - z,"(t/t)-t") define_sfop3(13
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::define_sfop3 (14,(x/y) *z,"(t/t)*t") define_sfop3(15
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::x (y+z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::t (t+t)") define_sfop3(16
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::x (y - z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::t (t-t)") define_sfop3(17
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::x (y *z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::t (t *t)") define_sfop3(18
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::x (y/z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	exprtk::details::t (t/t)") define_sfop3(19
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t	exprtk::details::define_sfop3 (20, x *(y - z),"t*(t-t)") define_sfop3(21
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::define_sfop3 (22, x *(y/z),"t*(t/t)") define_sfop3(23
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::axnb< T, 2 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::define_sfop3 (32,(axnb< T, 3 >(x, y, z))," ") define_sfop3(33
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::axnb< T, 4 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::define_sfop3 (34,(axnb< T, 5 >(x, y, z))," ") define_sfop3(35
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::axnb< T, 6 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::define_sfop3 (36,(axnb< T, 7 >(x, y, z))," ") define_sfop3(37
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::axnb< T, 8 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	exprtk::details::define_sfop3 (38,(axnb< T, 9 >(x, y, z))," ") define_sfop3(39
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x	exprtk::details::define_sfop3 (40, x *numeric::log(y) - z,"") define_sfop3(41
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x x	exprtk::details::define_sfop3 (42, x *numeric::log10(y) - z,"") define_sfop3(43
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x x x	exprtk::details::define_sfop3 (44, x *numeric::sin(y) - z,"") define_sfop3(45
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x x x x	exprtk::details::define_sfop3 (46, x *numeric::cos(y) - z,"") define_sfop3(47
	exprtk::details::exprtk_define_unary_op (abs) exprtk_define_unary_op(acos) exprtk_define_unary_op(acosh) exprtk_define_unary_op(asin) exprtk_define_unary_op(asinh) exprtk_define_unary_op(atan) exprtk_define_unary_op(atanh) exprtk_define_unary_op(ceil) exprtk_define_unary_op(cos) exprtk_define_unary_op(cosh) exprtk_define_unary_op(cot) exprtk_define_unary_op(csc) exprtk_define_unary_op(d2g) exprtk_define_unary_op(d2r) exprtk_define_unary_op(erf) exprtk_define_unary_op(erfc) exprtk_define_unary_op(exp) exprtk_define_unary_op(expm1) exprtk_define_unary_op(floor) exprtk_define_unary_op(frac) exprtk_define_unary_op(g2d) exprtk_define_unary_op(log) exprtk_define_unary_op(log10) exprtk_define_unary_op(log2) exprtk_define_unary_op(log1p) exprtk_define_unary_op(ncdf) exprtk_define_unary_op(neg) exprtk_define_unary_op(notl) exprtk_define_unary_op(pos) exprtk_define_unary_op(r2d) exprtk_define_unary_op(round) exprtk_define_unary_op(sec) exprtk_define_unary_op(sgn) exprtk_define_unary_op(sin) exprtk_define_unary_op(sinc) exprtk_define_unary_op(sinh) exprtk_define_unary_op(sqrt) exprtk_define_unary_op(tan) exprtk_define_unary_op(tanh) exprtk_define_unary_op(trunc) template< typename T > struct opr_base
template<typename T >
T	exprtk::details::value (details::expression_node< T > *n)
template<typename T >
T	exprtk::details::value (std::pair< details::expression_node< T > *, bool > n)
template<typename T >
T	exprtk::details::value (const T *t)
template<typename T >
T	exprtk::details::value (const T &t)
	exprtk::details::synthesis_node_type_define (const T0 &, const T1 &, e_vov) synthesis_node_type_define(const T0 &
const e_voc	exprtk::details::synthesis_node_type_define (const T0, const T1 &, e_cov) synthesis_node_type_define(T0 &
const e_voc T1 e_none	exprtk::details::synthesis_node_type_define (const T0, const T1, e_none) synthesis_node_type_define(T0 &
const e_voc T1 e_none const e_none	exprtk::details::synthesis_node_type_define (const T0, T1 &, e_none) synthesis_node_type_define(const T0 &
const e_voc T1 e_none const e_none T1 e_none	exprtk::details::synthesis_node_type_define (T0 &, const T1 &, e_none) template< typename T
	exprtk::details::synthesis_node_type_define (const T0 &, const T1 &, const T2 &, e_vovov) synthesis_node_type_define(const T0 &
const T1 const e_vovoc	exprtk::details::synthesis_node_type_define (const T0 &, const T1, const T2 &, e_vocov) synthesis_node_type_define(const T0
const T1 const e_vovoc const T1 const T2 e_covov	exprtk::details::synthesis_node_type_define (const T0, const T1 &, const T2, e_covoc) synthesis_node_type_define(const T0
const T1 const e_vovoc const T1 const T2 e_covov const const e_none	exprtk::details::synthesis_node_type_define (const T0, const T1, const T2 &, e_none) synthesis_node_type_define(const T0 &
const T1 const e_vovoc const T1 const T2 e_covov const const e_none const const e_none	exprtk::details::synthesis_node_type_define (T0 &, T1 &, T2 &, e_none) template< typename T
	exprtk::details::synthesis_node_type_define (const T0 &, const T1 &, const T2 &, const T3 &, e_vovovov) synthesis_node_type_define(const T0 &
const T1 const T2 const e_vovovoc	exprtk::details::synthesis_node_type_define (const T0 &, const T1 &, const T2, const T3 &, e_vovocov) synthesis_node_type_define(const T0 &
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov	exprtk::details::synthesis_node_type_define (const T0, const T1 &, const T2 &, const T3 &, e_covovov) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov	exprtk::details::synthesis_node_type_define (const T0 &, const T1, const T2 &, const T3, e_vocovoc) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc	exprtk::details::synthesis_node_type_define (const T0 &, const T1, const T2, const T3 &, e_vococov) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none	exprtk::details::synthesis_node_type_define (const T0, const T1, const T2, const T3 &, e_none) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none	exprtk::details::synthesis_node_type_define (const T0, const T1 &, const T2, const T3, e_none) synthesis_node_type_define(const T0 &
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none const const const e_none	exprtk::details::synthesis_node_type_define (const T0, const T1, const T2 &, const T3 &, e_none) synthesis_node_type_define(const T0 &
template<typename T >
bool	exprtk::details::is_sf3ext_node (const expression_node< T > *n)
template<typename T >
bool	exprtk::details::is_sf4ext_node (const expression_node< T > *n)
template<typename T >
bool	exprtk::details::is_vov_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_cov_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_voc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_cob_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_boc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_t0ot1ot2_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_t0ot1ot2ot3_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_uv_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_range_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_const_string_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_const_string_range_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_assignment_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_concat_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_function_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_condition_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_ccondition_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_vararg_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_genricstring_range_node (const expression_node< T > *node)
void	exprtk::details::load_operations_map (std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)
template<typename FunctionType >
void	exprtk::enable_zero_parameters (FunctionType &func)
template<typename FunctionType >
void	exprtk::disable_zero_parameters (FunctionType &func)
template<typename FunctionType >
void	exprtk::enable_has_side_effects (FunctionType &func)
template<typename FunctionType >
void	exprtk::disable_has_side_effects (FunctionType &func)
template<typename FunctionType >
void	exprtk::set_min_num_args (FunctionType &func, const std::size_t &num_args)
template<typename FunctionType >
void	exprtk::set_max_num_args (FunctionType &func, const std::size_t &num_args)
template<typename T >
bool	exprtk::is_valid (const expression< T > &expr)
type	exprtk::parser_error::make_error (const error_mode mode, const std::string &diagnostic="", const std::string &src_location="")
type	exprtk::parser_error::make_error (const error_mode mode, const lexer::token &tk, const std::string &diagnostic="", const std::string &src_location="")
std::string	exprtk::parser_error::to_str (error_mode mode)
bool	exprtk::parser_error::update_error (type &error, const std::string &expression)
void	exprtk::parser_error::dump_error (const type &error)
template<typename Parser >
void	exprtk::details::disable_type_checking (Parser &p)
template<typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_variables (const std::string &expression, Sequence< std::string, Allocator > &symbol_list)
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_variables (const std::string &expression, exprtk::symbol_table< T > &extrnl_symbol_table, Sequence< std::string, Allocator > &symbol_list)
template<typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_functions (const std::string &expression, Sequence< std::string, Allocator > &symbol_list)
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_functions (const std::string &expression, exprtk::symbol_table< T > &extrnl_symbol_table, Sequence< std::string, Allocator > &symbol_list)
template<typename T >
T	exprtk::integrate (const expression< T > &e, T &x, const T &r0, const T &r1, const std::size_t number_of_intervals=1000000)
template<typename T >
T	exprtk::integrate (const expression< T > &e, const std::string &variable_name, const T &r0, const T &r1, const std::size_t number_of_intervals=1000000)
template<typename T >
T	exprtk::derivative (const expression< T > &e, T &x, const T &h=T(0.00000001))
template<typename T >
T	exprtk::second_derivative (const expression< T > &e, T &x, const T &h=T(0.00001))
template<typename T >
T	exprtk::third_derivative (const expression< T > &e, T &x, const T &h=T(0.0001))
template<typename T >
T	exprtk::derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.00000001))
template<typename T >
T	exprtk::second_derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.00001))
template<typename T >
T	exprtk::third_derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.0001))
template<typename T >
bool	exprtk::compute (const std::string &expression_string, T &result)
template<typename T >
bool	exprtk::compute (const std::string &expression_string, const T &x, T &result)
template<typename T >
bool	exprtk::compute (const std::string &expression_string, const T &x, const T &y, T &result)
template<typename T >
bool	exprtk::compute (const std::string &expression_string, const T &x, const T &y, const T &z, T &result)
template<typename T >
bool	exprtk::pgo_primer ()
template<typename T >
void	exprtk::rtl::io::details::print_type (const std::string &fmt, const T v, exprtk::details::numeric::details::real_type_tag)
template<typename T >
file_descriptor *	exprtk::rtl::io::file::details::make_handle (T v)
template<typename T >
void	exprtk::rtl::io::file::details::perform_check ()
template<typename Vector >
bool	exprtk::rtl::vecops::helper::invalid_range (const Vector &v, const std::size_t r0, const std::size_t r1)
template<typename T >
void	exprtk::rtl::vecops::details::kahan_sum (T &sum, T &error, const T v)
static std::string	exprtk::information::data ()

Variables
static const std::string	exprtk::details::reserved_words []
static const std::size_t	exprtk::details::reserved_words_size = sizeof(reserved_words) / sizeof(std::string)
static const std::string	exprtk::details::reserved_symbols []
static const std::size_t	exprtk::details::reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string)
static const std::string	exprtk::details::base_function_list []
static const std::size_t	exprtk::details::base_function_list_size = sizeof(base_function_list) / sizeof(std::string)
static const std::string	exprtk::details::logic_ops_list []
static const std::size_t	exprtk::details::logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string)
static const std::string	exprtk::details::cntrl_struct_list []
static const std::size_t	exprtk::details::cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string)
static const std::string	exprtk::details::arithmetic_ops_list []
static const std::size_t	exprtk::details::arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string)
static const std::string	exprtk::details::assignment_ops_list []
static const std::size_t	exprtk::details::assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string)
static const std::string	exprtk::details::inequality_ops_list []
static const std::size_t	exprtk::details::inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string)
static const double	exprtk::details::pow10 []
static const std::size_t	exprtk::details::pow10_size = sizeof(pow10) / sizeof(double)
static const double	exprtk::details::numeric::constant::e = 2.71828182845904523536028747135266249775724709369996
static const double	exprtk::details::numeric::constant::pi = 3.14159265358979323846264338327950288419716939937510
static const double	exprtk::details::numeric::constant::pi_2 = 1.57079632679489661923132169163975144209858469968755
static const double	exprtk::details::numeric::constant::pi_4 = 0.78539816339744830961566084581987572104929234984378
static const double	exprtk::details::numeric::constant::pi_180 = 0.01745329251994329576923690768488612713442871888542
static const double	exprtk::details::numeric::constant::_1_pi = 0.31830988618379067153776752674502872406891929148091
static const double	exprtk::details::numeric::constant::_2_pi = 0.63661977236758134307553505349005744813783858296183
static const double	exprtk::details::numeric::constant::_180_pi = 57.29577951308232087679815481410517033240547246656443
static const double	exprtk::details::numeric::constant::log2 = 0.69314718055994530941723212145817656807550013436026
static const double	exprtk::details::numeric::constant::sqrt2 = 1.41421356237309504880168872420969807856967187537695
	exprtk::details::numeric::details::real_type_tag
const unsigned int	exprtk::details::loop_unroll::global_loop_batch_size = 16
x y *	exprtk::details::z
const	exprtk::details::T1
const e_voc T1 e_none const e_none T1 e_none	exprtk::details::T0
const T1 const	exprtk::details::T2
const T1 const T2 const	exprtk::details::T3
static const char *	exprtk::information::library = "Mathematical Expression Toolkit"
static const char *	exprtk::information::version
static const char *	exprtk::information::date = "20210101"

Macro Definition Documentation

base_opr_case

#define base_opr_case

(

N

)

Value:

                     case N : {                                                       \
                                 expression_node_ptr pl##N[N] = {0};                  \
                                 std::copy(param_list, param_list + N, pl##N);        \
                                 lodge_symbol(operation_name, e_st_function);         \
                                 return expression_generator_(operation.type, pl##N); \
                              }                                                       \

basic_opr_switch_statements

#define basic_opr_switch_statements

Value:

         case_stmt(details::e_add, details::add_op) \
         case_stmt(details::e_sub, details::sub_op) \
         case_stmt(details::e_mul, details::mul_op) \
         case_stmt(details::e_div, details::div_op) \
         case_stmt(details::e_mod, details::mod_op) \
         case_stmt(details::e_pow, details::pow_op) \

batch_eqineq_logic_case

#define batch_eqineq_logic_case

Value:

            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) \

case_stmt [1/56]

#define case_stmt

(

cp

)

Value:

               case cp : return node_allocator_->                                        \
                            allocate<IPowNode<T,details::numeric::fast_exp<T,cp> > >(v); \

case_stmt [2/56]

#define case_stmt

(

N

)

case N : { std::swap(s0[i], s1[i]); ++i; } \

case_stmt [3/56]

#define case_stmt

(

N

)

case N : *vec++ = v; \

case_stmt [4/56]

#define case_stmt

(

N

)

case N : *vec0++ = *vec1++; \

case_stmt [5/56]

#define case_stmt

(

N

)

case N : Operation::assign(*vec++,v); \

case_stmt [6/56]

#define case_stmt

(

N

)

case N : { vec0[i] = Operation::process(vec0[i], vec1[i]); ++i; } \

case_stmt [7/56]

#define case_stmt

(

N

)

case N : { vec2[i] = Operation::process(vec0[i], vec1[i]); ++i; } \

case_stmt [8/56]

#define case_stmt

(

N

)

case N : { vec1[i] = Operation::process(vec0[i], v); ++i; } \

case_stmt [9/56]

#define case_stmt

(

N

)

case N : { vec0[i] = Operation::process(v, vec1[i]); ++i; } \

case_stmt [10/56]

#define case_stmt

(

N

)

case N : { vec1[i] = Operation::process(vec0[i]); ++i; } \

case_stmt [11/56]

#define case_stmt

(

N

)

case N : result += vec[i++]; \

case_stmt [12/56]

#define case_stmt

(

N

)

case N : r[0] += vec[i++]; \

case_stmt [13/56]

#define case_stmt

(

N

)

case N : result *= vec[i++]; \

case_stmt [14/56]

#define case_stmt

(

N

)

case N : r[0] *= vec[i++]; \

case_stmt [15/56]

#define case_stmt

(

N

)

if (is_true(arg[(2 * N)].first)) { return arg[(2 * N) + 1].first->value(); } \

case_stmt [16/56]

#define case_stmt

(

N

)

Value:

               case N :                                                             \
                  return node_allocator_->                                          \
                            allocate<details::switch_n_node                         \
                              <Type,typename switch_nodes::switch_##N> >(arg_list); \

case_stmt [17/56]

#define case_stmt

(

N

)

Value:

            case N : (fp_map_[arg_count])[name] =                    \
                     (!ret_present) ? static_cast<base_func*>        \
                                      (new func_##N##param) :        \
                                      static_cast<base_func*>        \
                                      (new func_##N##param_retval) ; \
                     break;                                          \

case_stmt [18/56]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : temp_node = node_allocator_->                       \
                             allocate<details::sf3_node<Type,details::sf##op##_op<Type> > > \
                                (operation, branch);                                        \
                             break;                                                         \

case_stmt [19/56]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : return node_allocator_->                                    \
                             allocate_rrr<details::sf3_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2);                                                       \

case_stmt [20/56]

#define case_stmt

(

op

)

Value:

                  case details::e_sf##op : return node_allocator_->                            \
                                allocate<details::sf3_node<Type,details::sf##op##_op<Type> > > \
                                   (operation, branch);                                        \

case_stmt [21/56]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : temp_node = node_allocator_->                                   \
                                         allocate<details::sf4_node<Type,details::sf##op##_op<Type> > > \
                                            (operation, branch);                                        \
                                        break;                                                          \

case_stmt [22/56]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : return node_allocator_->                                     \
                             allocate_rrrr<details::sf4_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2, v3);                                                    \

case_stmt [23/56]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : return node_allocator_->                            \
                             allocate<details::sf4_node<Type,details::sf##op##_op<Type> > > \
                                (operation, branch);                                        \

case_stmt [24/56]

#define case_stmt

(

op

)

Value:

                  case details::e_sf##op : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,details::sf##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2);                                   \

case_stmt [25/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                 \
                             allocate<typename details::unary_variable_node<Type,op1<Type> > >(v); \

case_stmt [26/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                           \
                             allocate<typename details::unary_vector_node<Type,op1<Type> > > \
                                (operation, branch[0]);                                      \

case_stmt [27/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                       \
                             allocate<typename details::unary_branch_node<Type,op1<Type> > >(branch[0]); \

case_stmt [28/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : temp_node = node_allocator_->                                   \
                                         allocate<details::vararg_node<Type,op1<Type> > > \
                                            (arg_list);                                   \
                          break;                                                          \

case_stmt [29/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                          \
                             allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \

case_stmt [30/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                             \
                                allocate<details::vectorize_node<Type,op1<Type> > >(arg_list[0]); \

case_stmt [31/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                       \
                                allocate<details::vararg_node<Type,op1<Type> > >(arg_list); \

case_stmt [32/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                         \
                                template allocate_rrr<typename details::assignment_op_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                         \

case_stmt [33/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                                   \
                                 template allocate_rrr<typename details::assignment_vec_elem_op_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                  \

case_stmt [34/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                                         \
                                 template allocate_rrr<typename details::assignment_rebasevec_elem_op_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                        \

case_stmt [35/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                                          \
                                 template allocate_rrr<typename details::assignment_rebasevec_celem_op_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                         \

case_stmt [36/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                     case op0 : return node_allocator_->                                                                \
                                   template allocate_rrr<typename details::assignment_vecvec_op_node<Type,op1<Type> > > \
                                      (operation, branch[0], branch[1]);                                                \

case_stmt [37/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                     case op0 : return node_allocator_->                                                             \
                                   template allocate_rrr<typename details::assignment_vec_op_node<Type,op1<Type> > > \
                                      (operation, branch[0], branch[1]);                                             \

case_stmt [38/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                            \
                                template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \

case_stmt [39/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                            \
                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \

case_stmt [40/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                            \
                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \

case_stmt [41/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                            \
                                template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \

case_stmt [42/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                            \
                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \

case_stmt [43/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                                            \
                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \

case_stmt [44/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                         \
                                template allocate<typename details::binary_ext_node<Type,op1<Type> > > \
                                   (branch[0], branch[1]);                                             \

case_stmt [45/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::vob_node<Type,op1<Type> > > \
                                   (v, branch[1]);                                                 \

case_stmt [46/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::bov_node<Type,op1<Type> > > \
                                   (branch[0], v);                                                 \

case_stmt [47/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_tt<typename details::cob_node<Type,op1<Type> > > \
                                   (c,  branch[1]);                                                \

case_stmt [48/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::boc_node<Type,op1<Type> > > \
                                   (branch[0], c);                                                 \

case_stmt [49/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rr<typename details::vov_node<Type,op1<Type> > > \
                                   (v1, v2);                                                       \

case_stmt [50/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::cov_node<Type,op1<Type> > > \
                                   (c, v);                                                         \

case_stmt [51/56]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::voc_node<Type,op1<Type> > > \
                                   (v, c);                                                         \

case_stmt [52/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                              \
                             allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp0);                                                                  \

case_stmt [53/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                              \
                             allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp1);                                                                  \

case_stmt [54/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                                \
                             allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp0, rp1);                                                               \

case_stmt [55/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                         \
                             allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0, s1); \

case_stmt [56/56]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                              \
                             allocate_ttt<typename details::str_sogens_node<Type,op1<Type> > >  \
                                (opr, branch[0], branch[1]);                                    \

case_stmt0

#define case_stmt0

(

op

)

Value:

                  case details::e_sf##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sf##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3);                                        \

case_stmt1

#define case_stmt1

(

op

)

Value:

                  case details::e_sf4ext##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sfext##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3);                                               \

def_fp_retval

#define def_fp_retval

(

N

)

Value:

      struct func_##N##param_retval : public func_##N##param \
      {                                                      \
         inline T value(expression_t& e)                     \
         {                                                   \
            return return_value(e);                          \
         }                                                   \
      };                                                     \

define_sfop3

#define define_sfop3	(		NN,
			OP0,
			OP1
	)

Value:

      template <typename T>                              \
      struct sf##NN##_op : public sf_base<T>             \
      {                                                  \
         typedef typename sf_base<T>::Type const Type;   \
         static inline T process(Type x, Type y, Type z) \
         {                                               \
            return (OP0);                                \
         }                                               \
         static inline std::string id()                  \
         {                                               \
            return (OP1);                                \
         }                                               \
      };                                                 \

define_sfop4

#define define_sfop4	(		NN,
			OP0,
			OP1
	)

Value:

      template <typename T>                                      \
      struct sf##NN##_op : public sf_base<T>                     \
      {                                                          \
         typedef typename sf_base<T>::Type const Type;           \
         static inline T process(Type x, Type y, Type z, Type w) \
         {                                                       \
            return (OP0);                                        \
         }                                                       \
         static inline std::string id()                          \
         {                                                       \
            return (OP1);                                        \
         }                                                       \
      };                                                         \

else_stmt

#define else_stmt

(

N

)

Value:

            else if (details::is_true(details::numeric::nequal(details::numeric::fast_exp<T,N>::result(v),details::numeric::pow(v,T(N))))) \
               return false;                                                                                                               \

empty_method_body

#define empty_method_body

(

N

)

Value:

      {                                              \
         exprtk_debug(("ifunction::operator() - Operator(" #N ") has not been overridden\n")); \
         return std::numeric_limits<T>::quiet_NaN(); \
      }                                              \

exprtk_crtype

#define exprtk_crtype

(

Type

)

param_to_str<is_const_ref< Type >::result>::result() \

exprtk_debug

#define exprtk_debug

(

params

)

(void)0

exprtk_define_epsilon_type

#define exprtk_define_epsilon_type	(		Type,
			Epsilon
	)

Value:

            template <> struct epsilon_type<Type>             \
            {                                                 \
               static inline Type value()                     \
               {                                              \
                  const Type epsilon = static_cast<Type>(Epsilon);         \
                  return epsilon;                             \
               }                                              \
            };                                                \

exprtk_define_erf

#define exprtk_define_erf	(		TT,
			impl
	)		inline TT erf_impl(TT v) { return impl(v); } \

exprtk_define_erfc

#define exprtk_define_erfc	(		TT,
			impl
	)		inline TT erfc_impl(TT v) { return impl(v); } \

exprtk_define_freefunction

#define exprtk_define_freefunction

(

NN

)

Value:

      inline bool add_function(const std::string& function_name, ff##NN##_functor function) \
      {                                                                                     \
         if (!valid())                                                                      \
         { return false; }                                                                  \
         if (!valid_symbol(function_name))                                                  \
         { return false; }                                                                  \
         if (symbol_exists(function_name))                                                  \
         { return false; }                                                                  \
                                                                                            \
         exprtk::ifunction<T>* ifunc = new freefunc##NN(function);                          \
                                                                                            \
         local_data().free_function_list_.push_back(ifunc);                                 \
                                                                                            \
         return add_function(function_name,(*local_data().free_function_list_.back()));     \
      }                                                                                     \

exprtk_define_process

#define exprtk_define_process

(

Type

)

Value:

            static inline void process(std::pair<bool,Type*>& n) \
            {                                                    \
               delete n.second;                                  \
            }                                                    \

exprtk_define_unary_function

#define exprtk_define_unary_function

(

FunctionName

)

Value:

         template <typename T>                                     \
         inline T FunctionName (const T v)                         \
         {                                                         \
            const typename details::number_type<T>::type num_type; \
            return  FunctionName##_impl(v,num_type);               \
         }                                                         \

exprtk_define_unary_op

#define exprtk_define_unary_op

(

OpName

)

Value:

      template <typename T>                                     \
      struct OpName##_op                                        \
      {                                                         \
         typedef typename functor_t<T>::Type Type;              \
         typedef typename expression_node<T>::node_type node_t; \
                                                                \
         static inline T process(Type v)                        \
         {                                                      \
            return numeric:: OpName (v);                        \
         }                                                      \
                                                                \
         static inline node_t type()                            \
         {                                                      \
            return expression_node<T>::e_##OpName;              \
         }                                                      \
                                                                \
         static inline details::operator_type operation()       \
         {                                                      \
            return details::e_##OpName;                         \
         }                                                      \
      };                                                        \

exprtk_disable_fallthrough_begin

#define exprtk_disable_fallthrough_begin   (void)0;

exprtk_disable_fallthrough_end

#define exprtk_disable_fallthrough_end   (void)0;

exprtk_error_location

#define exprtk_error_location    "exprtk.hpp:" + details::to_str(__LINE__) \

exprtk_loop [1/11]

#define exprtk_loop

(

N

)

std::swap(s0[N], s1[N]); \

exprtk_loop [2/11]

#define exprtk_loop

(

N

)

vec[N] = v; \

exprtk_loop [3/11]

#define exprtk_loop

(

N

)

vec0[N] = vec1[N]; \

exprtk_loop [4/11]

#define exprtk_loop

(

N

)

Operation::assign(vec[N],v); \

exprtk_loop [5/11]

#define exprtk_loop

(

N

)

vec0[N] = Operation::process(vec0[N], vec1[N]); \

exprtk_loop [6/11]

#define exprtk_loop

(

N

)

vec2[N] = Operation::process(vec0[N], vec1[N]); \

exprtk_loop [7/11]

#define exprtk_loop

(

N

)

vec1[N] = Operation::process(vec0[N], v); \

exprtk_loop [8/11]

#define exprtk_loop

(

N

)

vec0[N] = Operation::process(v, vec1[N]); \

exprtk_loop [9/11]

#define exprtk_loop

(

N

)

vec1[N] = Operation::process(vec0[N]); \

exprtk_loop [10/11]

#define exprtk_loop

(

N

)

r[N] += vec[N]; \

exprtk_loop [11/11]

#define exprtk_loop

(

N

)

r[N] *= vec[N]; \

exprtk_process_digit

#define exprtk_process_digit

Value:

               if ((digit = (*itr++ - zero)) < 10)  \
                  result = result * T(10) + digit;  \
               else                                 \
               {                                    \
                  return_result = false;            \
                  break;                            \
               }                                    \

exprtk_register_complex_type_tag

#define exprtk_register_complex_type_tag

(

T

)

Value:

            template <> struct number_type<std::complex<T> >     \
            { typedef complex_type_tag type; number_type() {} }; \

exprtk_register_function [1/3]

#define exprtk_register_function	(		FunctionName,
			FunctionType
	)

Value:

         if (!symtab.add_function(FunctionName,FunctionType))                     \
         {                                                                        \
            exprtk_debug((                                                        \
              "exprtk::rtl::io::register_package - Failed to add function: %s\n", \
              FunctionName));                                                     \
            return false;                                                         \
         }                                                                        \

exprtk_register_function [2/3]

#define exprtk_register_function	(		FunctionName,
			FunctionType
	)

Value:

         if (!symtab.add_function(FunctionName,FunctionType))                           \
         {                                                                              \
            exprtk_debug((                                                              \
              "exprtk::rtl::io::file::register_package - Failed to add function: %s\n", \
              FunctionName));                                                           \
            return false;                                                               \
         }                                                                              \

exprtk_register_function [3/3]

#define exprtk_register_function	(		FunctionName,
			FunctionType
	)

Value:

         if (!symtab.add_function(FunctionName,FunctionType))                         \
         {                                                                            \
            exprtk_debug((                                                            \
              "exprtk::rtl::vecops::register_package - Failed to add function: %s\n", \
              FunctionName));                                                         \
            return false;                                                             \
         }                                                                            \

exprtk_register_int_type_tag

#define exprtk_register_int_type_tag

(

T

)

Value:

            template <> struct number_type<T>                    \
            { typedef int_type_tag type; number_type() {} };     \

exprtk_register_real_type_tag

#define exprtk_register_real_type_tag

(

T

)

Value:

            template <> struct number_type<T>                    \
            { typedef real_type_tag type; number_type() {} };    \

extended_opr_switch_statements

#define extended_opr_switch_statements

Value:

         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_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) \

igeneric_function_empty_body

#define igeneric_function_empty_body

(

N

)

Value:

      {                                              \
         exprtk_debug(("igeneric_function::operator() - Operator(" #N ") has not been overridden\n")); \
         return std::numeric_limits<T>::quiet_NaN(); \
      }                                              \

parse_digit_1

#define parse_digit_1

(

d

)

Value:

         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
         if (end == ++itr) break;          \

parse_digit_2

#define parse_digit_2

(

d

)

Value:

         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else { break; }                   \
            ++itr;                         \

poly_rtrn

#define poly_rtrn

(

NN

)

return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :

register_binary_op [1/2]

#define register_binary_op	(		Op,
			BinaryFunctor
	)		m.insert(value_type(Op,BinaryFunctor<T>::process)); \

register_binary_op [2/2]

#define register_binary_op	(		Op,
			BinaryFunctor
	)		m.insert(value_type(BinaryFunctor<T>::process,Op)); \

register_op

#define register_op	(		Symbol,
			Type,
			Args
	)		m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \

register_sf3

#define register_sf3

(

Op

)

sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \

register_sf3_extid

#define register_sf3_extid	(		Id,
			Op
	)		sf3_map[Id] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \

register_sf4

#define register_sf4

(

Op

)

sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \

register_sf4ext

#define register_sf4ext

(

Op

)

sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \

register_synthezier

#define register_synthezier

(

S

)

synthesize_map_[S ::node_type::id()] = S ::process; \

register_unary_op

#define register_unary_op	(		Op,
			UnaryFunctor
	)		m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \

string_opr_switch_statements

#define string_opr_switch_statements

Value:

         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_in   ,details::   in_op) \
         case_stmt(details::e_like ,details:: like_op) \
         case_stmt(details::e_ilike,details::ilike_op) \

synthesis_node_type_define [1/3]

#define synthesis_node_type_define	(		T0_,
			T1_,
			T2_,
			T3_,
			v_
	)

Value:

      template <typename T, typename T0, typename T1, typename T2, typename T3>                                               \
      struct nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_> { static const typename expression_node<T>::node_type result; };         \
      template <typename T, typename T0, typename T1, typename T2, typename T3>                                               \
      const typename expression_node<T>::node_type nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_>::result = expression_node<T>:: v_; \

synthesis_node_type_define [2/3]

#define synthesis_node_type_define	(		T0_,
			T1_,
			T2_,
			v_
	)

Value:

      template <typename T, typename T0, typename T1, typename T2>                                                     \
      struct nodetype_T0oT1oT2<T,T0_,T1_,T2_> { static const typename expression_node<T>::node_type result; };         \
      template <typename T, typename T0, typename T1, typename T2>                                                     \
      const typename expression_node<T>::node_type nodetype_T0oT1oT2<T,T0_,T1_,T2_>::result = expression_node<T>:: v_; \

synthesis_node_type_define [3/3]

#define synthesis_node_type_define	(		T0_,
			T1_,
			v_
	)

Value:

      template <typename T, typename T0, typename T1>                                                           \
      struct nodetype_T0oT1<T,T0_,T1_> { static const typename expression_node<T>::node_type result; };         \
      template <typename T, typename T0, typename T1>                                                           \
      const typename expression_node<T>::node_type nodetype_T0oT1<T,T0_,T1_>::result = expression_node<T>:: v_; \

token_inserter_empty_body

#define token_inserter_empty_body

Value:

         {                                 \
            return -1;                     \
         }                                 \

unary_opr_switch_statements

#define unary_opr_switch_statements

vector_ops

#define vector_ops

Value:

            case_stmt(details::e_add,details::add_op) \
            case_stmt(details::e_sub,details::sub_op) \
            case_stmt(details::e_mul,details::mul_op) \
            case_stmt(details::e_div,details::div_op) \
            case_stmt(details::e_mod,details::mod_op) \