Exprtk.hpp File Reference

#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#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>

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::set_zero_value_impl< T >
struct	exprtk::details::numeric::details::unknown_type_tag
struct	exprtk::details::numeric::details::real_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::vector_access_runtime_check
struct	exprtk::vector_access_runtime_check::violation_context
struct	exprtk::compilation_check
struct	exprtk::compilation_check::compilation_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::exprtk_final< T >
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::vec_data_store< T >::control_block
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::vector_holder< Type >::vector_holder_base
class	exprtk::details::vector_holder< Type >::exprtk_final< Allocator, Sequence >
class	exprtk::details::exprtk_final< T >
class	exprtk::details::range_interface< T >
class	exprtk::details::string_base_node< T >
class	exprtk::details::unary_node< T >
class	exprtk::details::binary_node< T >
class	exprtk::details::trinary_node< T >
class	exprtk::details::quaternary_node< T >
class	exprtk::details::break_exception< T >
class	exprtk::details::continue_exception
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::ivariable< T >
struct	exprtk::details::range_pack< T >
struct	exprtk::details::range_data_type< T >
class	exprtk::details::vector_interface< T >
struct	exprtk::details::asn_assignment
struct	exprtk::details::asn_addassignment
struct	exprtk::details::sf_base< T >
struct	exprtk::details::memory_context_t< T >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, BranchCount >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, 6 >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, 5 >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, 4 >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, 3 >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, 2 >
struct	exprtk::details::exprtk_final< T >::evaluate_branches< T_, 1 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, ParamCount >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 20 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 19 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 18 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 17 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 16 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 15 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 14 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 13 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 12 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 11 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 10 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 9 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 8 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 7 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 6 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 5 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 4 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 3 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 2 >
struct	exprtk::details::exprtk_final< T >::invoke< T_, 1 >
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::return_exception
class	exprtk::details::null_igenfunc< 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::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 >
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::sf3ext_type_node< T, T0, T1, T2 >
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::node_allocator
class	exprtk::function_traits
class	exprtk::ifunction< T >
class	exprtk::ivararg_function< T >
class	exprtk::igeneric_function< T >
class	exprtk::stringvar_base< T >
class	exprtk::symbol_table< T >
struct	exprtk::symbol_table< T >::exprtk_final
struct	exprtk::symbol_table< T >::freefunc05
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
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 >::scope_element
class	exprtk::parser< T >::scope_element_manager
class	exprtk::parser< T >::scope_handler
struct	exprtk::parser< T >::halfopen_range_policy< T_ >
struct	exprtk::parser< T >::closed_range_policy< T_ >
class	exprtk::parser< T >::interval_container_t< IntervalPointType, RangePolicy >
class	exprtk::parser< T >::stack_limit_handler
struct	exprtk::parser< T >::symtab_store
struct	exprtk::parser< T >::symtab_store::variable_context
struct	exprtk::parser< T >::symtab_store::vector_context
struct	exprtk::parser< T >::symtab_store::string_context
struct	exprtk::parser< T >::parser_state
struct	exprtk::parser< T >::unknown_symbol_resolver
class	exprtk::parser< T >::dependent_entity_collector
class	exprtk::parser< T >::settings_store
struct	exprtk::parser< T >::state_t
struct	exprtk::parser< T >::scoped_expression_delete
struct	exprtk::parser< T >::scoped_delete< Type, N >
struct	exprtk::parser< T >::scoped_deq_delete< Type >
struct	exprtk::parser< T >::scoped_vec_delete< Type >
struct	exprtk::parser< T >::scoped_bool_negator
struct	exprtk::parser< T >::scoped_bool_or_restorer
struct	exprtk::parser< T >::scoped_inc_dec
class	exprtk::parser< T >::type_checker
struct	exprtk::parser< T >::type_checker::function_prototype_t
struct	exprtk::parser< T >::parse_special_function_impl< Type, NumberOfParameters >
class	exprtk::parser< T >::expression_generator< Type >
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_1
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_2
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_3
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_4
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_5
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_6
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_7
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_binary_ext_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cocob_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_coboc_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vov_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cov_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_voc_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_sf3ext_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_sf4ext_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococ_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococ_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression4
struct	exprtk::details::collector_helper< T >
struct	exprtk::details::collector_helper< T >::resolve_as_vector
class	exprtk::polynomial< T, N >
struct	exprtk::polynomial< T, N >::poly_impl< Type, NumberOfCoefficients >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 12 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 11 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 10 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 9 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 8 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 7 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 6 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 5 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 4 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 3 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 2 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 1 >
class	exprtk::function_compositor< T >
struct	exprtk::function_compositor< T >::function
struct	exprtk::function_compositor< T >::base_func
struct	exprtk::function_compositor< T >::func_0param
struct	exprtk::function_compositor< T >::scoped_bft< BaseFuncType >
struct	exprtk::function_compositor< T >::func_1param
struct	exprtk::function_compositor< T >::func_2param
struct	exprtk::function_compositor< T >::func_3param
struct	exprtk::function_compositor< T >::func_4param
struct	exprtk::function_compositor< T >::func_5param
struct	exprtk::function_compositor< T >::func_6param
class	exprtk::timer
struct	exprtk::type_defs< T >
struct	exprtk::rtl::io::details::print_impl< T >
struct	exprtk::rtl::io::exprtk_final< T >
struct	exprtk::rtl::io::package< T >
struct	exprtk::rtl::io::file::details::file_descriptor
struct	exprtk::rtl::io::file::exprtk_final< T >
struct	exprtk::rtl::io::file::package< T >
struct	exprtk::rtl::vecops::helper::load_vector_range< T >
class	exprtk::rtl::vecops::exprtk_final< T >
struct	exprtk::rtl::vecops::package< T >

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

Macros
#define	exprtk_disable_caseinsensitivity
#define	exprtk_debug(params)   (void)0
#define	exprtk_error_location    "exprtk.hpp:" + details::to_str(__LINE__) \
#define	exprtk_override
#define	exprtk_final
#define	exprtk_delete
#define	exprtk_fallthrough
#define	pod_set_zero_value(T)
#define	exprtk_register_real_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(const TT v) { return impl(v); } \
#define	exprtk_define_erfc(TT, impl)    inline TT erfc_impl(const 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)
#define	define_sfop3(NN, OP0, OP1)
#define	define_sfop4(NN, OP0, OP1)
#define	exprtk_loop(N)    vec[N] = v; \
#define	case_stmt(N)
#define	exprtk_loop(N)    vec0[N] = vec1[N]; \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    Operation::assign(vec[N],v); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec0[N] = Operation::process(vec0[N], vec1[N]); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec2[N] = Operation::process(vec0[N], vec1[N]); \
#define	case_stmt(N)
#define	exprtk_loop(N)    vec1[N] = Operation::process(vec0[N], v); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec0[N] = Operation::process(v, vec1[N]); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec1[N] = Operation::process(vec0[N]); \
#define	case_stmt(N)
#define	exprtk_define_unary_op(OpName)
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    r[N] += vec[N]; \
#define	case_stmt(N, fall_through)
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    r[N] *= vec[N]; \
#define	case_stmt(N, fall_through)
#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	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	exprtk_assign(Index)    (*v[Index]) = v##Index; \
#define	def_fp_retval(N)
#define	case_stmt(N)
#define	exprtk_register_function(FunctionName, FunctionType)
#define	exprtk_register_function(FunctionName, FunctionType)
#define	exprtk_register_function(FunctionName, FunctionType)

Typedefs
typedef char	exprtk::details::char_t
typedef char_t *	exprtk::details::char_ptr
typedef char_t const *	exprtk::details::char_cptr
typedef unsigned char	exprtk::details::uchar_t
typedef uchar_t *	exprtk::details::uchar_ptr
typedef uchar_t const *	exprtk::details::uchar_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
typedef vector_access_runtime_check *	exprtk::vector_access_runtime_check_ptr
typedef compilation_check *	exprtk::compilation_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_synthesis = 7 , exprtk::parser_error::e_helper = 8 ,   exprtk::parser_error::e_parser = 9 }
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 &)
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 uchar_t digit)
uchar_t	exprtk::details::hex_to_bin (uchar_t h)
template<typename Iterator >
bool	exprtk::details::parse_hex (Iterator &itr, Iterator end, char_t &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 &exactly_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::pod_set_zero_value (float) pod_set_zero_value(double) pod_set_zero_value(long double) template< typename T > inline void set_zero_value(T *data
template<typename T >
void	exprtk::details::set_zero_value (std::vector< T > &v)
	exprtk::details::numeric::details::exprtk_register_real_type_tag (float) exprtk_register_real_type_tag(double) exprtk_register_real_type_tag(long double) 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.00000100000f) 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 >
_uint64_t	exprtk::details::numeric::details::to_uint64_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(const T v
template<typename T >
T	exprtk::details::numeric::details::erf_impl (const 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(const T v
template<typename T >
T	exprtk::details::numeric::details::erfc_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ncdf_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ncdf_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinc_impl (const 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::const_qnan_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 >
_uint64_t	exprtk::details::numeric::to_uint64 (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, const 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 >
void	exprtk::details::dump_vector (const std::string &, const T *, 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 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_literal_node (const expression_node< T > *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_vector_celem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_elem_rtc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_celem_rtc_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_elem_rtc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_celem_rtc_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 (const expression_node< T > *node)
template<std::size_t N, typename T >
bool	exprtk::details::all_nodes_valid (expression_node< T > *const (&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 > *const (&b)[N])
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::details::all_nodes_variables (const 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 (const T a, const T x)
template<typename T , std::size_t N>
T	exprtk::details::axnb (const T a, const T x, const 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
template<typename T >
memory_context_t< T >	exprtk::details::make_memory_context (vector_holder< T > &vec_holder, vec_data_store< T > &vds)
template<typename T >
memory_context_t< T >	exprtk::details::make_memory_context (vector_holder< T > &vec_holder0, vector_holder< T > &vec_holder1, vec_data_store< T > &vds)
	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 >
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)
const std::size_t	exprtk::details::size
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
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 char_cptr	exprtk::information::library = "Mathematical Expression Toolkit"
static char_cptr	exprtk::information::version
static char_cptr	exprtk::information::date = "20240101"
static char_cptr	exprtk::information::min_cpp = "199711L"

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/60]

#define case_stmt

(

cp

)

Value:

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

case_stmt [2/60]

#define case_stmt

(

N

)

Value:

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

case_stmt [3/60]

#define case_stmt

(

N

)

Value:

               case N : *vec++ = v; \
               exprtk_fallthrough   \

case_stmt [4/60]

#define case_stmt

(

N

)

Value:

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

case_stmt [5/60]

#define case_stmt

(

N

)

Value:

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

case_stmt [6/60]

#define case_stmt

(

N

)

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

case_stmt [7/60]

#define case_stmt

(

N

)

Value:

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

case_stmt [8/60]

#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 [9/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [10/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [11/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [12/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [13/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [14/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [15/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [16/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [17/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

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

case_stmt [18/60]

#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/60]

#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/60]

#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/60]

#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/60]

#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/60]

#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/60]

#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/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [26/60]

#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/60]

#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/60]

#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/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [30/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [31/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [32/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [33/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [34/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                     \
                                 template allocate_rrr<typename details::assignment_vec_elem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                      \
                             node_name = "assignment_vec_elem_op_rtc_node";                                                 \
                             break;                                                                                         \

case_stmt [35/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                      \
                                 template allocate_rrr<typename details::assignment_vec_celem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                       \
                             node_name = "assignment_vec_celem_op_rtc_node";                                                 \
                             break;                                                                                          \

case_stmt [36/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [37/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [38/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                           \
                                 template allocate_rrr<typename details::assignment_rebasevec_elem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                            \
                             node_name = "assignment_rebasevec_elem_op_rtc_node";                                                 \
                             break;                                                                                               \

case_stmt [39/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                            \
                                 template allocate_rrr<typename details::assignment_rebasevec_celem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                             \
                             node_name = "assignment_rebasevec_celem_op_rtc_node";                                                 \
                             break;                                                                                                \

case_stmt [40/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                     case op0 : result = node_allocator_->                                                              \
                                   template allocate_rrr<typename details::assignment_vecvec_op_node<Type,op1<Type> > > \
                                      (operation, branch[0], branch[1]);                                                \
                                node_name = "assignment_rebasevec_celem_op_node";                                       \
                                break;                                                                                  \

case_stmt [41/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [42/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [43/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [44/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [45/60]

#define case_stmt	(		op0,
			op1
	)

Value:

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

case_stmt [46/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecval_node(b0ivec,!b1ivec)";                                \
                             break;                                                                              \

case_stmt [47/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecval_node(!b0ivec,b1ivec)";                                \
                             break;                                                                              \

case_stmt [48/60]

#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 [49/60]

#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 [50/60]

#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 [51/60]

#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 [52/60]

#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 [53/60]

#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 [54/60]

#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 [55/60]

#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 [56/60]

#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 [57/60]

#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 [58/60]

#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 [59/60]

#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 [60/60]

#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 exprtk_final : public func_##N##param \
      {                                                                   \
         inline T value(expression_t& e) exprtk_override                  \
         {                                                                \
            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);                                        \
         }                                                       \
      };                                                         \

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_assign

#define exprtk_assign

(

Index

)

(*v[Index]) = v##Index; \

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(const TT v) { return impl(v); } \

exprtk_define_erfc

#define exprtk_define_erfc	(		TT,
			impl
	)		inline TT erfc_impl(const 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_delete

#define exprtk_delete

exprtk_disable_caseinsensitivity

#define exprtk_disable_caseinsensitivity

exprtk_error_location

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

exprtk_fallthrough

#define exprtk_fallthrough

exprtk_final

#define exprtk_final

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_override

#define exprtk_override

exprtk_process_digit

#define exprtk_process_digit

Value:

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

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

pod_set_zero_value

#define pod_set_zero_value

(

T

)

Value:

      template <>                                                        \
      struct set_zero_value_impl<T>                                      \
      {                                                                  \
         static inline void process(T* base_ptr, const std::size_t size) \
         { std::memset(base_ptr, 0x00, size * sizeof(T)); }              \
      };                                                                 \

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

Value:

         case_stmt(details::e_abs   , details::abs_op  ) \
         case_stmt(details::e_acos  , details::acos_op ) \
         case_stmt(details::e_acosh , details::acosh_op) \
         case_stmt(details::e_asin  , details::asin_op ) \
         case_stmt(details::e_asinh , details::asinh_op) \
         case_stmt(details::e_atan  , details::atan_op ) \
         case_stmt(details::e_atanh , details::atanh_op) \
         case_stmt(details::e_ceil  , details::ceil_op ) \
         case_stmt(details::e_cos   , details::cos_op  ) \
         case_stmt(details::e_cosh  , details::cosh_op ) \
         case_stmt(details::e_exp   , details::exp_op  ) \
         case_stmt(details::e_expm1 , details::expm1_op) \
         case_stmt(details::e_floor , details::floor_op) \
         case_stmt(details::e_log   , details::log_op  ) \
         case_stmt(details::e_log10 , details::log10_op) \
         case_stmt(details::e_log2  , details::log2_op ) \
         case_stmt(details::e_log1p , details::log1p_op) \
         case_stmt(details::e_neg   , details::neg_op  ) \
         case_stmt(details::e_pos   , details::pos_op  ) \
         case_stmt(details::e_round , details::round_op) \
         case_stmt(details::e_sin   , details::sin_op  ) \
         case_stmt(details::e_sinc  , details::sinc_op ) \
         case_stmt(details::e_sinh  , details::sinh_op ) \
         case_stmt(details::e_sqrt  , details::sqrt_op ) \
         case_stmt(details::e_tan   , details::tan_op  ) \
         case_stmt(details::e_tanh  , details::tanh_op ) \
         case_stmt(details::e_cot   , details::cot_op  ) \
         case_stmt(details::e_sec   , details::sec_op  ) \
         case_stmt(details::e_csc   , details::csc_op  ) \
         case_stmt(details::e_r2d   , details::r2d_op  ) \
         case_stmt(details::e_d2r   , details::d2r_op  ) \
         case_stmt(details::e_d2g   , details::d2g_op  ) \
         case_stmt(details::e_g2d   , details::g2d_op  ) \
         case_stmt(details::e_notl  , details::notl_op ) \
         case_stmt(details::e_sgn   , details::sgn_op  ) \
         case_stmt(details::e_erf   , details::erf_op  ) \
         case_stmt(details::e_erfc  , details::erfc_op ) \
         case_stmt(details::e_ncdf  , details::ncdf_op ) \
         case_stmt(details::e_frac  , details::frac_op ) \
         case_stmt(details::e_trunc , details::trunc_op) \

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