exprtk::details Namespace Reference

Namespaces
namespace	constant
namespace	loop_unroll
namespace	numeric

Classes
struct	ilesscompare
class	build_string
struct	cs_match
struct	cis_match
struct	set_zero_value_impl
struct	set_zero_value_impl< float >
struct	set_zero_value_impl< double >
struct	set_zero_value_impl< long double >
struct	functor_t
class	vector_interface
class	return_node
class	return_envelope_node
struct	base_operation_t
class	vec_data_store
struct	node_collector_interface
struct	node_depth_base
class	expression_node
class	unary_node
class	node_collection_destructor
class	vector_holder
class	null_node
class	null_eq_node
class	literal_node
struct	range_pack
struct	range_data_type
class	range_interface
class	string_base_node
class	string_literal_node
class	binary_node
class	binary_ext_node
class	trinary_node
class	quaternary_node
class	conditional_node
class	cons_conditional_node
class	break_exception
class	continue_exception
class	break_node
class	continue_node
struct	loop_runtime_checker
class	while_loop_node
class	while_loop_rtc_node
class	repeat_until_loop_node
class	repeat_until_loop_rtc_node
class	for_loop_node
class	for_loop_rtc_node
class	while_loop_bc_node
class	while_loop_bc_rtc_node
class	repeat_until_loop_bc_node
class	repeat_until_loop_bc_rtc_node
class	for_loop_bc_node
class	for_loop_bc_rtc_node
class	switch_node
class	switch_n_node
class	multi_switch_node
class	ivariable
class	variable_node
class	vector_node
class	vector_size_node
class	vector_elem_node
class	vector_celem_node
class	vector_elem_rtc_node
class	vector_celem_rtc_node
class	rebasevector_elem_node
class	rebasevector_celem_node
class	rebasevector_elem_rtc_node
class	rebasevector_celem_rtc_node
class	vector_initialisation_node
class	vector_init_zero_value_node
class	vector_init_single_constvalue_node
class	vector_init_single_value_node
class	vector_init_iota_constconst_node
class	vector_init_iota_constnconst_node
class	vector_init_iota_nconstconst_node
class	vector_init_iota_nconstnconst_node
class	swap_node
class	swap_generic_node
class	swap_vecvec_node
class	stringvar_node
class	string_range_node
class	const_string_range_node
class	generic_string_range_node
class	string_concat_node
class	swap_string_node
class	swap_genstrings_node
class	stringvar_size_node
class	string_size_node
struct	asn_assignment
struct	asn_addassignment
class	assignment_string_node
class	assignment_string_range_node
class	conditional_string_node
class	cons_conditional_str_node
class	str_vararg_node
class	assert_node
struct	sf_base
struct	sf00_op
struct	sf01_op
struct	sf02_op
struct	sf03_op
struct	sf04_op
struct	sf05_op
struct	sf06_op
struct	sf07_op
struct	sf08_op
struct	sf09_op
struct	sf10_op
struct	sf11_op
struct	sf12_op
struct	sf13_op
struct	sf14_op
struct	sf15_op
struct	sf16_op
struct	sf17_op
struct	sf18_op
struct	sf19_op
struct	sf20_op
struct	sf21_op
struct	sf22_op
struct	sf23_op
struct	sf24_op
struct	sf25_op
struct	sf26_op
struct	sf27_op
struct	sf28_op
struct	sf29_op
struct	sf30_op
struct	sf31_op
struct	sf32_op
struct	sf33_op
struct	sf34_op
struct	sf35_op
struct	sf36_op
struct	sf37_op
struct	sf38_op
struct	sf39_op
struct	sf40_op
struct	sf41_op
struct	sf42_op
struct	sf43_op
struct	sf44_op
struct	sf45_op
struct	sf46_op
struct	sf47_op
struct	sf48_op
struct	sf49_op
struct	sf50_op
struct	sf51_op
struct	sf52_op
struct	sf53_op
struct	sf54_op
struct	sf55_op
struct	sf56_op
struct	sf57_op
struct	sf58_op
struct	sf59_op
struct	sf60_op
struct	sf61_op
struct	sf62_op
struct	sf63_op
struct	sf64_op
struct	sf65_op
struct	sf66_op
struct	sf67_op
struct	sf68_op
struct	sf69_op
struct	sf70_op
struct	sf71_op
struct	sf72_op
struct	sf73_op
struct	sf74_op
struct	sf75_op
struct	sf76_op
struct	sf77_op
struct	sf78_op
struct	sf79_op
struct	sf80_op
struct	sf81_op
struct	sf82_op
struct	sf83_op
struct	sf84_op
struct	sf85_op
struct	sf86_op
struct	sf87_op
struct	sf88_op
struct	sf89_op
struct	sf90_op
struct	sf91_op
struct	sf92_op
struct	sf93_op
struct	sf94_op
struct	sf95_op
struct	sf96_op
struct	sf97_op
struct	sf98_op
struct	sf99_op
struct	sfext00_op
struct	sfext01_op
struct	sfext02_op
struct	sfext03_op
struct	sfext04_op
struct	sfext05_op
struct	sfext06_op
struct	sfext07_op
struct	sfext08_op
struct	sfext09_op
struct	sfext10_op
struct	sfext11_op
struct	sfext12_op
struct	sfext13_op
struct	sfext14_op
struct	sfext15_op
struct	sfext16_op
struct	sfext17_op
struct	sfext18_op
struct	sfext19_op
struct	sfext20_op
struct	sfext21_op
struct	sfext22_op
struct	sfext23_op
struct	sfext24_op
struct	sfext25_op
struct	sfext26_op
struct	sfext27_op
struct	sfext28_op
struct	sfext29_op
struct	sfext30_op
struct	sfext31_op
struct	sfext32_op
struct	sfext33_op
struct	sfext34_op
struct	sfext35_op
struct	sfext36_op
struct	sfext37_op
struct	sfext38_op
struct	sfext39_op
struct	sfext40_op
struct	sfext41_op
struct	sfext42_op
struct	sfext43_op
struct	sfext44_op
struct	sfext45_op
struct	sfext46_op
struct	sfext47_op
struct	sfext48_op
struct	sfext49_op
struct	sfext50_op
struct	sfext51_op
struct	sfext52_op
struct	sfext53_op
struct	sfext54_op
struct	sfext55_op
struct	sfext56_op
struct	sfext57_op
struct	sfext58_op
struct	sfext59_op
struct	sfext60_op
struct	sfext61_op
class	sf3_node
class	sf4_node
class	sf3_var_node
class	sf4_var_node
class	vararg_node
class	vararg_varnode
class	vectorize_node
class	assignment_node
class	assignment_vec_elem_node
class	assignment_vec_elem_rtc_node
class	assignment_rebasevec_elem_node
class	assignment_rebasevec_elem_rtc_node
class	assignment_rebasevec_celem_node
class	assignment_vec_node
class	assignment_vecvec_node
class	assignment_op_node
class	assignment_vec_elem_op_node
class	assignment_vec_elem_op_rtc_node
class	assignment_vec_celem_op_rtc_node
class	assignment_rebasevec_elem_op_node
class	assignment_rebasevec_celem_op_node
class	assignment_rebasevec_elem_op_rtc_node
class	assignment_rebasevec_celem_op_rtc_node
class	assignment_vec_op_node
class	assignment_vecvec_op_node
struct	memory_context_t
class	vec_binop_vecvec_node
class	vec_binop_vecval_node
class	vec_binop_valvec_node
class	unary_vector_node
class	conditional_vector_node
class	scand_node
class	scor_node
class	function_N_node
class	function_N_node< T, IFunction, 0 >
class	vararg_function_node
class	generic_function_node
class	string_function_node
class	multimode_genfunction_node
class	multimode_strfunction_node
class	return_exception
class	null_igenfunc
struct	abs_op
struct	acos_op
struct	acosh_op
struct	asin_op
struct	asinh_op
struct	atan_op
struct	atanh_op
struct	ceil_op
struct	cos_op
struct	cosh_op
struct	cot_op
struct	csc_op
struct	d2g_op
struct	d2r_op
struct	erf_op
struct	erfc_op
struct	exp_op
struct	expm1_op
struct	floor_op
struct	frac_op
struct	g2d_op
struct	log_op
struct	log10_op
struct	log2_op
struct	log1p_op
struct	ncdf_op
struct	neg_op
struct	notl_op
struct	pos_op
struct	r2d_op
struct	round_op
struct	sec_op
struct	sgn_op
struct	sin_op
struct	sinc_op
struct	sinh_op
struct	sqrt_op
struct	tan_op
struct	tanh_op
struct	trunc_op
struct	opr_base
struct	add_op
struct	mul_op
struct	sub_op
struct	div_op
struct	mod_op
struct	pow_op
struct	lt_op
struct	lte_op
struct	gt_op
struct	gte_op
struct	eq_op
struct	equal_op
struct	ne_op
struct	and_op
struct	nand_op
struct	or_op
struct	nor_op
struct	xor_op
struct	xnor_op
struct	in_op
struct	like_op
struct	ilike_op
struct	inrange_op
struct	vararg_add_op
struct	vararg_mul_op
struct	vararg_avg_op
struct	vararg_min_op
struct	vararg_max_op
struct	vararg_mand_op
struct	vararg_mor_op
struct	vararg_multi_op
struct	vec_add_op
struct	vec_mul_op
struct	vec_avg_op
struct	vec_min_op
struct	vec_max_op
class	vov_base_node
class	cov_base_node
class	voc_base_node
class	vob_base_node
class	bov_base_node
class	cob_base_node
class	boc_base_node
class	uv_base_node
class	sos_base_node
class	sosos_base_node
class	T0oT1oT2_base_node
class	T0oT1oT2oT3_base_node
class	unary_variable_node
class	uvouv_node
class	unary_branch_node
struct	is_const
struct	is_const< const T >
struct	is_const_ref
struct	is_const_ref< const T & >
struct	is_ref
struct	is_ref< T & >
struct	is_ref< const T & >
struct	param_to_str
struct	param_to_str< 0 >
struct	T0oT1oT2process
struct	T0oT1oT20T3process
struct	nodetype_T0oT1
struct	nodetype_T0oT1< T, const T0 &, const T1 & >
struct	nodetype_T0oT1< T, const T0 &, const T1 >
struct	nodetype_T0oT1< T, const T0, const T1 & >
struct	nodetype_T0oT1< T, T0 &, T1 & >
struct	nodetype_T0oT1< T, const T0, const T1 >
struct	nodetype_T0oT1< T, T0 &, const T1 >
struct	nodetype_T0oT1< T, const T0, T1 & >
struct	nodetype_T0oT1< T, const T0 &, T1 & >
struct	nodetype_T0oT1< T, T0 &, const T1 & >
struct	nodetype_T0oT1oT2
struct	nodetype_T0oT1oT2< T, const T0 &, const T1 &, const T2 & >
struct	nodetype_T0oT1oT2< T, const T0 &, const T1 &, const T2 >
struct	nodetype_T0oT1oT2< T, const T0 &, const T1, const T2 & >
struct	nodetype_T0oT1oT2< T, const T0, const T1 &, const T2 & >
struct	nodetype_T0oT1oT2< T, const T0, const T1 &, const T2 >
struct	nodetype_T0oT1oT2< T, const T0, const T1, const T2 >
struct	nodetype_T0oT1oT2< T, const T0, const T1, const T2 & >
struct	nodetype_T0oT1oT2< T, const T0 &, const T1, const T2 >
struct	nodetype_T0oT1oT2< T, T0 &, T1 &, T2 & >
struct	nodetype_T0oT1oT2oT3
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2 &, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2 &, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2 &, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2 &, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2 &, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2 &, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2 &, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2, const T3 >
struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2 &, const T3 & >
struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2, const T3 >
class	T0oT1
class	T0oT1oT2
class	T0oT1oT2oT3
class	T0oT1oT2_sf3
class	sf3ext_type_node
class	T0oT1oT2_sf3ext
class	T0oT1oT2oT3_sf4
class	T0oT1oT2oT3_sf4ext
struct	T0oT1_define
struct	T0oT1oT2_define
struct	T0oT1oT2oT3_define
class	vov_node
class	cov_node
class	voc_node
class	vob_node
class	bov_node
class	cob_node
class	boc_node
class	sos_node
class	str_xrox_node
class	str_xoxr_node
class	str_xroxr_node
class	str_sogens_node
class	sosos_node
class	ipow_node
class	bipow_node
class	ipowinv_node
class	bipowinv_node
class	node_allocator
struct	collector_helper

Typedefs
typedef char	char_t
typedef char_t *	char_ptr
typedef char_t const *	char_cptr
typedef unsigned char	uchar_t
typedef uchar_t *	uchar_ptr
typedef uchar_t const *	uchar_cptr
typedef unsigned long long int	_uint64_t
typedef long long int	_int64_t

Enumerations

enum

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

Functions
bool	is_whitespace (const char_t c)
bool	is_operator_char (const char_t c)
bool	is_letter (const char_t c)
bool	is_digit (const char_t c)
bool	is_letter_or_digit (const char_t c)
bool	is_left_bracket (const char_t c)
bool	is_right_bracket (const char_t c)
bool	is_bracket (const char_t c)
bool	is_sign (const char_t c)
bool	is_invalid (const char_t c)
bool	is_valid_string_char (const char_t c)
void	case_normalise (std::string &s)
bool	imatch (const char_t c1, const char_t c2)
bool	imatch (const std::string &s1, const std::string &s2)
bool	is_valid_sf_symbol (const std::string &symbol)
const char_t &	front (const std::string &s)
const char_t &	back (const std::string &s)
template<typename SignedType>
std::string	to_str_impl (SignedType i)
std::string	to_str (int i)
std::string	to_str (std::size_t i)
bool	is_hex_digit (const uchar_t digit)
uchar_t	hex_to_bin (uchar_t h)
template<typename Iterator>
bool	parse_hex (Iterator &itr, Iterator end, char_t &result)
bool	cleanup_escapes (std::string &s)
bool	is_reserved_word (const std::string &symbol)
bool	is_reserved_symbol (const std::string &symbol)
bool	is_base_function (const std::string &function_name)
bool	is_control_struct (const std::string &cntrl_strct)
bool	is_logic_opr (const std::string &lgc_opr)
template<typename Iterator, typename Compare>
bool	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	wc_match (const std::string &wild_card, const std::string &str)
bool	wc_imatch (const std::string &wild_card, const std::string &str)
bool	sequence_match (const std::string &pattern, const std::string &str, std::size_t &diff_index, char_t &diff_value)
template<typename T>
void	set_zero_value (T *data, const std::size_t size)
template<typename T>
void	set_zero_value (std::vector< T > &v)
template<typename T>
T	compute_pow10 (T d, const int exponent)
template<typename Iterator, typename T>
bool	string_to_type_converter_impl_ref (Iterator &itr, const Iterator end, T &result)
template<typename Iterator, typename T>
static bool	parse_nan (Iterator &itr, const Iterator end, T &t)
template<typename Iterator, typename T>
static bool	parse_inf (Iterator &itr, const Iterator end, T &t, const bool negative)
template<typename T>
bool	valid_exponent (const int exponent, numeric::details::real_type_tag)
template<typename Iterator, typename T>
bool	string_to_real (Iterator &itr_external, const Iterator end, T &t, numeric::details::real_type_tag)
template<typename T>
bool	string_to_real (const std::string &s, T &t)
std::string	to_str (const operator_type opr)
void	dump_ptr (const std::string &, const void *)
void	dump_ptr (const std::string &, const void *, const std::size_t)
template<typename T>
void	dump_vector (const std::string &, const T *, const std::size_t)
template<typename T>
bool	is_generally_string_node (const expression_node< T > *node)
bool	is_true (const double v)
bool	is_true (const long double v)
bool	is_true (const float v)
template<typename T>
bool	is_true (const expression_node< T > *node)
template<typename T>
bool	is_true (const std::pair< expression_node< T > *, bool > &node)
template<typename T>
bool	is_false (const expression_node< T > *node)
template<typename T>
bool	is_false (const std::pair< expression_node< T > *, bool > &node)
template<typename T>
bool	is_literal_node (const expression_node< T > *node)
template<typename T>
bool	is_unary_node (const expression_node< T > *node)
template<typename T>
bool	is_neg_unary_node (const expression_node< T > *node)
template<typename T>
bool	is_binary_node (const expression_node< T > *node)
template<typename T>
bool	is_variable_node (const expression_node< T > *node)
template<typename T>
bool	is_ivariable_node (const expression_node< T > *node)
template<typename T>
bool	is_vector_elem_node (const expression_node< T > *node)
template<typename T>
bool	is_vector_celem_node (const expression_node< T > *node)
template<typename T>
bool	is_vector_elem_rtc_node (const expression_node< T > *node)
template<typename T>
bool	is_vector_celem_rtc_node (const expression_node< T > *node)
template<typename T>
bool	is_rebasevector_elem_node (const expression_node< T > *node)
template<typename T>
bool	is_rebasevector_elem_rtc_node (const expression_node< T > *node)
template<typename T>
bool	is_rebasevector_celem_rtc_node (const expression_node< T > *node)
template<typename T>
bool	is_rebasevector_celem_node (const expression_node< T > *node)
template<typename T>
bool	is_vector_node (const expression_node< T > *node)
template<typename T>
bool	is_ivector_node (const expression_node< T > *node)
template<typename T>
bool	amalgamated_vecop (const expression_node< T > *node)
template<typename T>
bool	is_constant_node (const expression_node< T > *node)
template<typename T>
bool	is_null_node (const expression_node< T > *node)
template<typename T>
bool	is_break_node (const expression_node< T > *node)
template<typename T>
bool	is_continue_node (const expression_node< T > *node)
template<typename T>
bool	is_swap_node (const expression_node< T > *node)
template<typename T>
bool	is_function (const expression_node< T > *node)
template<typename T>
bool	is_vararg_node (const expression_node< T > *node)
template<typename T>
bool	is_return_node (const expression_node< T > *node)
template<typename T>
bool	is_negate_node (const expression_node< T > *node)
template<typename T>
bool	is_assert_node (const expression_node< T > *node)
template<typename T>
bool	branch_deletable (const expression_node< T > *node)
template<std::size_t N, typename T>
bool	all_nodes_valid (expression_node< T > *const (&b)[N])
template<typename T, typename Allocator, template< typename, typename > class Sequence>
bool	all_nodes_valid (const Sequence< expression_node< T > *, Allocator > &b)
template<std::size_t N, typename T>
bool	all_nodes_variables (expression_node< T > *const (&b)[N])
template<typename T, typename Allocator, template< typename, typename > class Sequence>
bool	all_nodes_variables (const Sequence< expression_node< T > *, Allocator > &b)
template<typename NodeAllocator, typename T, std::size_t N>
void	free_all_nodes (NodeAllocator &node_allocator, expression_node< T > *(&b)[N])
template<typename NodeAllocator, typename T, typename Allocator, template< typename, typename > class Sequence>
void	free_all_nodes (NodeAllocator &node_allocator, Sequence< expression_node< T > *, Allocator > &b)
template<typename NodeAllocator, typename T>
void	free_node (NodeAllocator &, expression_node< T > *&node)
template<typename T>
void	destroy_node (expression_node< T > *&node)
template<typename T, std::size_t N>
void	construct_branch_pair (std::pair< expression_node< T > *, bool >(&branch)[N], expression_node< T > *b, const std::size_t &index)
template<typename T>
void	construct_branch_pair (std::pair< expression_node< T > *, bool > &branch, expression_node< T > *b)
template<std::size_t N, typename T>
void	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	axn (const T a, const T x)
template<typename T, std::size_t N>
T	axnb (const T a, const T x, const T b)
template<typename T>
memory_context_t< T >	make_memory_context (vector_holder< T > &vec_holder, vec_data_store< T > &vds)
template<typename T>
memory_context_t< T >	make_memory_context (vector_holder< T > &vec_holder0, vector_holder< T > &vec_holder1, vec_data_store< T > &vds)
template<typename T>
T	value (details::expression_node< T > *n)
template<typename T>
T	value (std::pair< details::expression_node< T > *, bool > n)
template<typename T>
T	value (const T *t)
template<typename T>
T	value (const T &t)
template<typename T>
bool	is_sf3ext_node (const expression_node< T > *n)
template<typename T>
bool	is_sf4ext_node (const expression_node< T > *n)
template<typename T>
bool	is_vov_node (const expression_node< T > *node)
template<typename T>
bool	is_cov_node (const expression_node< T > *node)
template<typename T>
bool	is_voc_node (const expression_node< T > *node)
template<typename T>
bool	is_cob_node (const expression_node< T > *node)
template<typename T>
bool	is_boc_node (const expression_node< T > *node)
template<typename T>
bool	is_t0ot1ot2_node (const expression_node< T > *node)
template<typename T>
bool	is_t0ot1ot2ot3_node (const expression_node< T > *node)
template<typename T>
bool	is_uv_node (const expression_node< T > *node)
template<typename T>
bool	is_string_node (const expression_node< T > *node)
template<typename T>
bool	is_string_range_node (const expression_node< T > *node)
template<typename T>
bool	is_const_string_node (const expression_node< T > *node)
template<typename T>
bool	is_const_string_range_node (const expression_node< T > *node)
template<typename T>
bool	is_string_assignment_node (const expression_node< T > *node)
template<typename T>
bool	is_string_concat_node (const expression_node< T > *node)
template<typename T>
bool	is_string_function_node (const expression_node< T > *node)
template<typename T>
bool	is_string_condition_node (const expression_node< T > *node)
template<typename T>
bool	is_string_ccondition_node (const expression_node< T > *node)
template<typename T>
bool	is_string_vararg_node (const expression_node< T > *node)
template<typename T>
bool	is_genricstring_range_node (const expression_node< T > *node)
template<typename T>
bool	is_loop_node (const expression_node< T > *node)
template<typename T>
bool	is_block_node (const expression_node< T > *node)
void	load_operations_map (std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)
template<typename Parser>
void	disable_type_checking (Parser &p)
bool	is_true (const cmplx::complex_t &v)
bool	is_false (const cmplx::complex_t &v)
template<typename Iterator>
bool	string_to_real (Iterator &itr_external, const Iterator end, cmplx::complex_t &t, details::numeric::details::complex_type_tag)
bool	is_true (const mpfr::mpreal &v)
bool	is_false (const mpfr::mpreal &v)
template<typename Iterator>
bool	string_to_real (Iterator &itr_external, const Iterator end, mpfr::mpreal &t, numeric::details::mpfrreal_type_tag)
bool	is_true (const real::type v)
bool	is_false (const real::type v)
template<typename Iterator>
bool	string_to_real (Iterator &itr_external, const Iterator end, real::type &t, details::numeric::details::my_real_type_tag)

Variables
static const std::string	reserved_words []
static const std::size_t	reserved_words_size = sizeof(reserved_words) / sizeof(std::string)
static const std::string	reserved_symbols []
static const std::size_t	reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string)
static const std::string	base_function_list []
static const std::size_t	base_function_list_size = sizeof(base_function_list) / sizeof(std::string)
static const std::string	logic_ops_list []
static const std::size_t	logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string)
static const std::string	cntrl_struct_list []
static const std::size_t	cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string)
static const std::string	arithmetic_ops_list []
static const std::size_t	arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string)
static const std::string	assignment_ops_list []
static const std::size_t	assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string)
static const std::string	inequality_ops_list []
static const std::size_t	inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string)
static const double	pow10 []
static const std::size_t	pow10_size = sizeof(pow10) / sizeof(double)
template<typename T>
T	variable_node< T >::null_value = T(std::numeric_limits<T>::quiet_NaN())
template<typename T>
std::string	stringvar_node< T >::null_value = std::string("")
template<typename T>
std::string	string_range_node< T >::null_value = std::string("")
template<typename T>
const std::string	stringvar_size_node< T >::null_value = std::string("")
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, T0, T1 >::result = expression_node<T>::e_none
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, constT0 &, constT1 & >::result = expression_node<T>:: e_vov
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, constT0 &, constT1 >::result = expression_node<T>:: e_voc
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, constT0, constT1 & >::result = expression_node<T>:: e_cov
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, T0 &, T1 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, constT0, constT1 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, T0 &, constT1 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, constT0, T1 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, constT0 &, T1 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1>
const expression_node< T >::node_type	nodetype_T0oT1< T, T0 &, constT1 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, T0, T1, T2 >::result = expression_node<T>::e_none
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0 &, constT1 &, constT2 & >::result = expression_node<T>:: e_vovov
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0 &, constT1 &, constT2 >::result = expression_node<T>:: e_vovoc
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0 &, constT1, constT2 & >::result = expression_node<T>:: e_vocov
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0, constT1 &, constT2 & >::result = expression_node<T>:: e_covov
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0, constT1 &, constT2 >::result = expression_node<T>:: e_covoc
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0, constT1, constT2 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0, constT1, constT2 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, constT0 &, constT1, constT2 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2>
const expression_node< T >::node_type	nodetype_T0oT1oT2< T, T0 &, T1 &, T2 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, T0, T1, T2, T3 >::result = expression_node<T>::e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2 &, constT3 & >::result = expression_node<T>:: e_vovovov
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2 &, constT3 >::result = expression_node<T>:: e_vovovoc
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2, constT3 & >::result = expression_node<T>:: e_vovocov
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2 &, constT3 & >::result = expression_node<T>:: e_vocovov
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2 &, constT3 & >::result = expression_node<T>:: e_covovov
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2, constT3 & >::result = expression_node<T>:: e_covocov
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2 &, constT3 >::result = expression_node<T>:: e_vocovoc
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2 &, constT3 >::result = expression_node<T>:: e_covovoc
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2, constT3 & >::result = expression_node<T>:: e_vococov
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2, constT3 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2, constT3 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2 &, constT3 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2, constT3 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2, constT3 >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2 &, constT3 & >::result = expression_node<T>:: e_none
template<typename T, typename T0, typename T1, typename T2, typename T3>
const expression_node< T >::node_type	nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2, constT3 >::result = expression_node<T>:: e_none

Typedef Documentation

_int64_t

typedef long long int exprtk::details::_int64_t

Definition at line 101 of file exprtk.hpp.

_uint64_t

typedef unsigned long long int exprtk::details::_uint64_t

Definition at line 100 of file exprtk.hpp.

char_cptr

typedef char_t const* exprtk::details::char_cptr

Definition at line 96 of file exprtk.hpp.

char_ptr

typedef char_t* exprtk::details::char_ptr

Definition at line 95 of file exprtk.hpp.

char_t

typedef char exprtk::details::char_t

Definition at line 94 of file exprtk.hpp.

uchar_cptr

typedef uchar_t const* exprtk::details::uchar_cptr

Definition at line 99 of file exprtk.hpp.

uchar_ptr

typedef uchar_t* exprtk::details::uchar_ptr

Definition at line 98 of file exprtk.hpp.

uchar_t

typedef unsigned char exprtk::details::uchar_t

Definition at line 97 of file exprtk.hpp.

Enumeration Type Documentation

operator_type

enum exprtk::details::operator_type

Enumerator
e_default
e_null
e_add
e_sub
e_mul
e_div
e_mod
e_pow
e_atan2
e_min
e_max
e_avg
e_sum
e_prod
e_lt
e_lte
e_eq
e_equal
e_ne
e_nequal
e_gte
e_gt
e_and
e_nand
e_or
e_nor
e_xor
e_xnor
e_mand
e_mor
e_scand
e_scor
e_shr
e_shl
e_abs
e_acos
e_acosh
e_asin
e_asinh
e_atan
e_atanh
e_ceil
e_cos
e_cosh
e_exp
e_expm1
e_floor
e_log
e_log10
e_log2
e_log1p
e_logn
e_neg
e_pos
e_round
e_roundn
e_root
e_sqrt
e_sin
e_sinc
e_sinh
e_sec
e_csc
e_tan
e_tanh
e_cot
e_clamp
e_iclamp
e_inrange
e_sgn
e_r2d
e_d2r
e_d2g
e_g2d
e_hypot
e_notl
e_erf
e_erfc
e_ncdf
e_frac
e_trunc
e_assign
e_addass
e_subass
e_mulass
e_divass
e_modass
e_in
e_like
e_ilike
e_multi
e_smulti
e_swap
e_sf00
e_sf01
e_sf02
e_sf03
e_sf04
e_sf05
e_sf06
e_sf07
e_sf08
e_sf09
e_sf10
e_sf11
e_sf12
e_sf13
e_sf14
e_sf15
e_sf16
e_sf17
e_sf18
e_sf19
e_sf20
e_sf21
e_sf22
e_sf23
e_sf24
e_sf25
e_sf26
e_sf27
e_sf28
e_sf29
e_sf30
e_sf31
e_sf32
e_sf33
e_sf34
e_sf35
e_sf36
e_sf37
e_sf38
e_sf39
e_sf40
e_sf41
e_sf42
e_sf43
e_sf44
e_sf45
e_sf46
e_sf47
e_sf48
e_sf49
e_sf50
e_sf51
e_sf52
e_sf53
e_sf54
e_sf55
e_sf56
e_sf57
e_sf58
e_sf59
e_sf60
e_sf61
e_sf62
e_sf63
e_sf64
e_sf65
e_sf66
e_sf67
e_sf68
e_sf69
e_sf70
e_sf71
e_sf72
e_sf73
e_sf74
e_sf75
e_sf76
e_sf77
e_sf78
e_sf79
e_sf80
e_sf81
e_sf82
e_sf83
e_sf84
e_sf85
e_sf86
e_sf87
e_sf88
e_sf89
e_sf90
e_sf91
e_sf92
e_sf93
e_sf94
e_sf95
e_sf96
e_sf97
e_sf98
e_sf99
e_sffinal
e_sf4ext00
e_sf4ext01
e_sf4ext02
e_sf4ext03
e_sf4ext04
e_sf4ext05
e_sf4ext06
e_sf4ext07
e_sf4ext08
e_sf4ext09
e_sf4ext10
e_sf4ext11
e_sf4ext12
e_sf4ext13
e_sf4ext14
e_sf4ext15
e_sf4ext16
e_sf4ext17
e_sf4ext18
e_sf4ext19
e_sf4ext20
e_sf4ext21
e_sf4ext22
e_sf4ext23
e_sf4ext24
e_sf4ext25
e_sf4ext26
e_sf4ext27
e_sf4ext28
e_sf4ext29
e_sf4ext30
e_sf4ext31
e_sf4ext32
e_sf4ext33
e_sf4ext34
e_sf4ext35
e_sf4ext36
e_sf4ext37
e_sf4ext38
e_sf4ext39
e_sf4ext40
e_sf4ext41
e_sf4ext42
e_sf4ext43
e_sf4ext44
e_sf4ext45
e_sf4ext46
e_sf4ext47
e_sf4ext48
e_sf4ext49
e_sf4ext50
e_sf4ext51
e_sf4ext52
e_sf4ext53
e_sf4ext54
e_sf4ext55
e_sf4ext56
e_sf4ext57
e_sf4ext58
e_sf4ext59
e_sf4ext60
e_sf4ext61

Definition at line 5144 of file exprtk.hpp.

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

Function Documentation

all_nodes_valid() [1/2]

template<typename T, typename Allocator, template< typename, typename > class Sequence>

bool exprtk::details::all_nodes_valid ( const Sequence< expression_node< T > *, Allocator > & b )

inline

Definition at line 6039 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            if (0 == b[i]) return false;
         }
 
         return true;
      }

all_nodes_valid() [2/2]

template<std::size_t N, typename T>

bool exprtk::details::all_nodes_valid ( expression_node< T > *const (&) b[N] )

inline

Definition at line 6026 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < N; ++i)
         {
            if (0 == b[i]) return false;
         }
 
         return true;
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_expression().

Here is the caller graph for this function:

all_nodes_variables() [1/2]

template<typename T, typename Allocator, template< typename, typename > class Sequence>

bool exprtk::details::all_nodes_variables ( const Sequence< expression_node< T > *, Allocator > & b )

inline

Definition at line 6066 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }
 
         return true;
      }

References is_variable_node().

Here is the call graph for this function:

all_nodes_variables() [2/2]

template<std::size_t N, typename T>

bool exprtk::details::all_nodes_variables ( expression_node< T > *const (&) b[N] )

inline

Definition at line 6050 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < N; ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }
 
         return true;
      }

References is_variable_node().

Here is the call graph for this function:

amalgamated_vecop()

template<typename T>

bool exprtk::details::amalgamated_vecop ( const expression_node< T > * node )

inline

Definition at line 5929 of file exprtk.hpp.

      {
         if (node)
         {
            switch (node->type())
            {
               case details::expression_node<T>::e_vecvecarith :
               case details::expression_node<T>::e_vecvalarith :
               case details::expression_node<T>::e_valvecarith :
               case details::expression_node<T>::e_vecunaryop  : return true;
               default                                         : return false;
            }
         }
         else
            return false;
      }

References exprtk::details::expression_node< T >::e_valvecarith, exprtk::details::expression_node< T >::e_vecunaryop, exprtk::details::expression_node< T >::e_vecvalarith, exprtk::details::expression_node< T >::e_vecvecarith, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::generic_function_node< T, StringFunction >::init_branches().

Here is the call graph for this function:

Here is the caller graph for this function:

axn()

template<typename T, std::size_t N>

T exprtk::details::axn ( const T a, const T x )

inline

Definition at line 11997 of file exprtk.hpp.

      {
         // a*x^n
         return a * exprtk::details::numeric::fast_exp<T,N>::result(x);
      }

References exprtk::details::numeric::fast_exp< T, N >::result().

Referenced by exprtk::details::sf84_op< T >::id(), exprtk::details::sf85_op< T >::id(), exprtk::details::sf86_op< T >::id(), exprtk::details::sf87_op< T >::id(), exprtk::details::sf88_op< T >::id(), exprtk::details::sf89_op< T >::id(), exprtk::details::sf90_op< T >::id(), and exprtk::details::sf91_op< T >::id().

Here is the call graph for this function:

Here is the caller graph for this function:

axnb()

template<typename T, std::size_t N>

T exprtk::details::axnb ( const T a, const T x, const T b )

inline

Definition at line 12004 of file exprtk.hpp.

      {
         // a*x^n+b
         return a * exprtk::details::numeric::fast_exp<T,N>::result(x) + b;
      }

References exprtk::details::numeric::fast_exp< T, N >::result().

Referenced by exprtk::details::sf31_op< T >::id(), exprtk::details::sf32_op< T >::id(), exprtk::details::sf33_op< T >::id(), exprtk::details::sf34_op< T >::id(), exprtk::details::sf35_op< T >::id(), exprtk::details::sf36_op< T >::id(), exprtk::details::sf37_op< T >::id(), and exprtk::details::sf38_op< T >::id().

Here is the call graph for this function:

Here is the caller graph for this function:

back()

const char_t & exprtk::details::back ( const std::string & s )

inline

Definition at line 272 of file exprtk.hpp.

      {
         return s[s.size() - 1];
      }

Referenced by exprtk::function_compositor< T >::compile_expression().

Here is the caller graph for this function:

branch_deletable()

template<typename T>

bool exprtk::details::branch_deletable ( const expression_node< T > * node )

inline

Definition at line 6018 of file exprtk.hpp.

      {
         return (0 != node)             &&
                !is_variable_node(node) &&
                !is_string_node  (node) ;
      }

References is_string_node(), and is_variable_node().

Referenced by exprtk::details::node_depth_base< expression_node< T > >::collect(), exprtk::details::node_depth_base< expression_node< T > >::collect(), construct_branch_pair(), construct_branch_pair(), exprtk::details::function_N_node< T, IFunction, N >::init_branches(), exprtk::details::generic_function_node< T, StringFunction >::init_branches(), and exprtk::expression< T >::control_block::~control_block().

Here is the call graph for this function:

Here is the caller graph for this function:

case_normalise()

void exprtk::details::case_normalise ( std::string & s )

inline

Definition at line 182 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < s.size(); ++i)
         {
            s[i] = static_cast<std::string::value_type>(std::tolower(s[i]));
         }
      }

Referenced by exprtk::parser< T >::dependent_entity_collector::assignment_symbols(), and exprtk::parser< T >::dependent_entity_collector::symbols().

Here is the caller graph for this function:

cleanup_escapes()

bool exprtk::details::cleanup_escapes ( std::string & s )

inline

Definition at line 352 of file exprtk.hpp.

      {
         typedef std::string::iterator str_itr_t;
 
         str_itr_t itr1 = s.begin();
         str_itr_t itr2 = s.begin();
         str_itr_t end  = s.end  ();
 
         std::size_t removal_count  = 0;
 
         while (end != itr1)
         {
            if ('\\' == (*itr1))
            {
               if (end == ++itr1)
               {
                  return false;
               }
               else if (parse_hex(itr1, end, *itr2))
               {
                  itr1 += 4;
                  itr2 += 1;
                  removal_count += 4;
               }
               else if ('a' == (*itr1)) { (*itr2++) = '\a'; ++itr1; ++removal_count; }
               else if ('b' == (*itr1)) { (*itr2++) = '\b'; ++itr1; ++removal_count; }
               else if ('f' == (*itr1)) { (*itr2++) = '\f'; ++itr1; ++removal_count; }
               else if ('n' == (*itr1)) { (*itr2++) = '\n'; ++itr1; ++removal_count; }
               else if ('r' == (*itr1)) { (*itr2++) = '\r'; ++itr1; ++removal_count; }
               else if ('t' == (*itr1)) { (*itr2++) = '\t'; ++itr1; ++removal_count; }
               else if ('v' == (*itr1)) { (*itr2++) = '\v'; ++itr1; ++removal_count; }
               else if ('0' == (*itr1)) { (*itr2++) = '\0'; ++itr1; ++removal_count; }
               else
               {
                  (*itr2++) = (*itr1++);
                  ++removal_count;
               }
 
               continue;
            }
            else
               (*itr2++) = (*itr1++);
         }
 
         if ((removal_count > s.size()) || (0 == removal_count))
            return false;
 
         s.resize(s.size() - removal_count);
 
         return true;
      }

References parse_hex().

Referenced by exprtk::lexer::generator::scan_string().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_pow10()

template<typename T>

T exprtk::details::compute_pow10 ( T d, const int exponent )

inline

Definition at line 1760 of file exprtk.hpp.

      {
         static const double fract10[] =
         {
            0.0,
            1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004, 1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008, 1.0E+009, 1.0E+010,
            1.0E+011, 1.0E+012, 1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016, 1.0E+017, 1.0E+018, 1.0E+019, 1.0E+020,
            1.0E+021, 1.0E+022, 1.0E+023, 1.0E+024, 1.0E+025, 1.0E+026, 1.0E+027, 1.0E+028, 1.0E+029, 1.0E+030,
            1.0E+031, 1.0E+032, 1.0E+033, 1.0E+034, 1.0E+035, 1.0E+036, 1.0E+037, 1.0E+038, 1.0E+039, 1.0E+040,
            1.0E+041, 1.0E+042, 1.0E+043, 1.0E+044, 1.0E+045, 1.0E+046, 1.0E+047, 1.0E+048, 1.0E+049, 1.0E+050,
            1.0E+051, 1.0E+052, 1.0E+053, 1.0E+054, 1.0E+055, 1.0E+056, 1.0E+057, 1.0E+058, 1.0E+059, 1.0E+060,
            1.0E+061, 1.0E+062, 1.0E+063, 1.0E+064, 1.0E+065, 1.0E+066, 1.0E+067, 1.0E+068, 1.0E+069, 1.0E+070,
            1.0E+071, 1.0E+072, 1.0E+073, 1.0E+074, 1.0E+075, 1.0E+076, 1.0E+077, 1.0E+078, 1.0E+079, 1.0E+080,
            1.0E+081, 1.0E+082, 1.0E+083, 1.0E+084, 1.0E+085, 1.0E+086, 1.0E+087, 1.0E+088, 1.0E+089, 1.0E+090,
            1.0E+091, 1.0E+092, 1.0E+093, 1.0E+094, 1.0E+095, 1.0E+096, 1.0E+097, 1.0E+098, 1.0E+099, 1.0E+100,
            1.0E+101, 1.0E+102, 1.0E+103, 1.0E+104, 1.0E+105, 1.0E+106, 1.0E+107, 1.0E+108, 1.0E+109, 1.0E+110,
            1.0E+111, 1.0E+112, 1.0E+113, 1.0E+114, 1.0E+115, 1.0E+116, 1.0E+117, 1.0E+118, 1.0E+119, 1.0E+120,
            1.0E+121, 1.0E+122, 1.0E+123, 1.0E+124, 1.0E+125, 1.0E+126, 1.0E+127, 1.0E+128, 1.0E+129, 1.0E+130,
            1.0E+131, 1.0E+132, 1.0E+133, 1.0E+134, 1.0E+135, 1.0E+136, 1.0E+137, 1.0E+138, 1.0E+139, 1.0E+140,
            1.0E+141, 1.0E+142, 1.0E+143, 1.0E+144, 1.0E+145, 1.0E+146, 1.0E+147, 1.0E+148, 1.0E+149, 1.0E+150,
            1.0E+151, 1.0E+152, 1.0E+153, 1.0E+154, 1.0E+155, 1.0E+156, 1.0E+157, 1.0E+158, 1.0E+159, 1.0E+160,
            1.0E+161, 1.0E+162, 1.0E+163, 1.0E+164, 1.0E+165, 1.0E+166, 1.0E+167, 1.0E+168, 1.0E+169, 1.0E+170,
            1.0E+171, 1.0E+172, 1.0E+173, 1.0E+174, 1.0E+175, 1.0E+176, 1.0E+177, 1.0E+178, 1.0E+179, 1.0E+180,
            1.0E+181, 1.0E+182, 1.0E+183, 1.0E+184, 1.0E+185, 1.0E+186, 1.0E+187, 1.0E+188, 1.0E+189, 1.0E+190,
            1.0E+191, 1.0E+192, 1.0E+193, 1.0E+194, 1.0E+195, 1.0E+196, 1.0E+197, 1.0E+198, 1.0E+199, 1.0E+200,
            1.0E+201, 1.0E+202, 1.0E+203, 1.0E+204, 1.0E+205, 1.0E+206, 1.0E+207, 1.0E+208, 1.0E+209, 1.0E+210,
            1.0E+211, 1.0E+212, 1.0E+213, 1.0E+214, 1.0E+215, 1.0E+216, 1.0E+217, 1.0E+218, 1.0E+219, 1.0E+220,
            1.0E+221, 1.0E+222, 1.0E+223, 1.0E+224, 1.0E+225, 1.0E+226, 1.0E+227, 1.0E+228, 1.0E+229, 1.0E+230,
            1.0E+231, 1.0E+232, 1.0E+233, 1.0E+234, 1.0E+235, 1.0E+236, 1.0E+237, 1.0E+238, 1.0E+239, 1.0E+240,
            1.0E+241, 1.0E+242, 1.0E+243, 1.0E+244, 1.0E+245, 1.0E+246, 1.0E+247, 1.0E+248, 1.0E+249, 1.0E+250,
            1.0E+251, 1.0E+252, 1.0E+253, 1.0E+254, 1.0E+255, 1.0E+256, 1.0E+257, 1.0E+258, 1.0E+259, 1.0E+260,
            1.0E+261, 1.0E+262, 1.0E+263, 1.0E+264, 1.0E+265, 1.0E+266, 1.0E+267, 1.0E+268, 1.0E+269, 1.0E+270,
            1.0E+271, 1.0E+272, 1.0E+273, 1.0E+274, 1.0E+275, 1.0E+276, 1.0E+277, 1.0E+278, 1.0E+279, 1.0E+280,
            1.0E+281, 1.0E+282, 1.0E+283, 1.0E+284, 1.0E+285, 1.0E+286, 1.0E+287, 1.0E+288, 1.0E+289, 1.0E+290,
            1.0E+291, 1.0E+292, 1.0E+293, 1.0E+294, 1.0E+295, 1.0E+296, 1.0E+297, 1.0E+298, 1.0E+299, 1.0E+300,
            1.0E+301, 1.0E+302, 1.0E+303, 1.0E+304, 1.0E+305, 1.0E+306, 1.0E+307, 1.0E+308
         };
 
         static const int fract10_size = static_cast<int>(sizeof(fract10) / sizeof(double));
 
         const int e = std::abs(exponent);
 
         if (exponent >= std::numeric_limits<T>::min_exponent10)
         {
            if (e < fract10_size)
            {
               if (exponent > 0)
                  return T(d * fract10[e]);
               else
                  return T(d / fract10[e]);
            }
            else
               return T(d * std::pow(10.0, 10.0 * exponent));
         }
         else
         {
                     d /= T(fract10[           -std::numeric_limits<T>::min_exponent10]);
            return T(d /    fract10[-exponent + std::numeric_limits<T>::min_exponent10]);
         }
      }

Referenced by string_to_real().

Here is the caller graph for this function:

construct_branch_pair() [1/2]

template<typename T>

void exprtk::details::construct_branch_pair ( std::pair< expression_node< T > *, bool > & branch, expression_node< T > * b )

inline

Definition at line 6810 of file exprtk.hpp.

      {
         if (b)
         {
            branch = std::make_pair(b,branch_deletable(b));
         }
      }

References branch_deletable().

Here is the call graph for this function:

construct_branch_pair() [2/2]

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 )

inline

Definition at line 6799 of file exprtk.hpp.

      {
         if (b && (index < N))
         {
            branch[index] = std::make_pair(b,branch_deletable(b));
         }
      }

References branch_deletable().

Referenced by exprtk::details::assert_node< T >::assert_node(), exprtk::details::bipow_node< T, PowOp >::bipow_node(), exprtk::details::bipowinv_node< T, PowOp >::bipowinv_node(), exprtk::details::boc_node< T, Operation >::boc_node(), exprtk::details::bov_node< T, Operation >::bov_node(), exprtk::details::break_node< T >::break_node(), exprtk::details::cob_node< T, Operation >::cob_node(), exprtk::details::conditional_node< T >::conditional_node(), exprtk::details::conditional_vector_node< T >::conditional_vector_node(), exprtk::details::cons_conditional_node< T >::cons_conditional_node(), exprtk::details::for_loop_node< T >::for_loop_node(), exprtk::details::generic_string_range_node< T >::generic_string_range_node(), init_branches(), exprtk::details::multi_switch_node< T >::multi_switch_node(), exprtk::details::null_eq_node< T >::null_eq_node(), exprtk::details::rebasevector_celem_node< T >::rebasevector_celem_node(), exprtk::details::rebasevector_celem_rtc_node< T >::rebasevector_celem_rtc_node(), exprtk::details::rebasevector_elem_node< T >::rebasevector_elem_node(), exprtk::details::rebasevector_elem_rtc_node< T >::rebasevector_elem_rtc_node(), exprtk::details::repeat_until_loop_node< T >::repeat_until_loop_node(), exprtk::details::return_envelope_node< T >::return_envelope_node(), exprtk::details::str_vararg_node< T, VarArgFunction >::str_vararg_node(), exprtk::details::string_size_node< T >::string_size_node(), exprtk::details::switch_node< T >::switch_node(), exprtk::details::unary_branch_node< T, Operation >::unary_branch_node(), exprtk::details::unary_node< T >::unary_node(), exprtk::details::vararg_node< T, VarArgFunction >::vararg_node(), exprtk::details::vector_celem_node< T >::vector_celem_node(), exprtk::details::vector_celem_rtc_node< T >::vector_celem_rtc_node(), exprtk::details::vector_elem_node< T >::vector_elem_node(), exprtk::details::vector_elem_rtc_node< T >::vector_elem_rtc_node(), exprtk::details::vectorize_node< T, VecFunction >::vectorize_node(), exprtk::details::vob_node< T, Operation >::vob_node(), and exprtk::details::while_loop_node< T >::while_loop_node().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_node()

template<typename T>

void exprtk::details::destroy_node ( expression_node< T > *& node )

inline

Definition at line 6185 of file exprtk.hpp.

      {
         if (0 != node)
         {
            node_collection_destructor<expression_node<T> >
               ::delete_nodes(node);
         }
      }

Referenced by exprtk::details::range_pack< T >::free().

Here is the caller graph for this function:

disable_type_checking()

template<typename Parser>

void exprtk::details::disable_type_checking ( Parser & p )

inline

Definition at line 22517 of file exprtk.hpp.

      {
         p.state_.type_check_enabled = false;
      }

Referenced by exprtk::details::collector_helper< T >::collection_pass().

Here is the caller graph for this function:

dump_ptr() [1/2]

void exprtk::details::dump_ptr ( const std::string & , const void *  )

inline

Definition at line 5312 of file exprtk.hpp.

{}

Referenced by exprtk::details::vec_data_store< T >::control_block::create_data(), exprtk::symtab_list_t< T >::release(), exprtk::details::vec_data_store< T >::control_block::~control_block(), and exprtk::symbol_table< T >::~symbol_table().

Here is the caller graph for this function:

dump_ptr() [2/2]

void exprtk::details::dump_ptr ( const std::string & , const void * , const std::size_t  )

inline

Definition at line 5313 of file exprtk.hpp.

{}

dump_vector()

template<typename T>

void exprtk::details::dump_vector ( const std::string & , const T * , const std::size_t  )

inline

Definition at line 5315 of file exprtk.hpp.

{}

free_all_nodes() [1/2]

template<typename NodeAllocator, typename T, std::size_t N>

void exprtk::details::free_all_nodes ( NodeAllocator & node_allocator, expression_node< T > *(&) b[N] )

inline

Definition at line 6150 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < N; ++i)
         {
            free_node(node_allocator,b[i]);
         }
      }

References free_node().

Referenced by exprtk::parser< T >::expression_generator< Type >::cardinal_pow_optimisation(), exprtk::parser< T >::expression_generator< Type >::generic_function_call(), exprtk::parser< T >::expression_generator< Type >::multi_switch_statement(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::synthesize_binary_ext_expression::process(), exprtk::parser< T >::expression_generator< Type >::return_call(), exprtk::parser< T >::expression_generator< Type >::string_function_call(), exprtk::parser< T >::expression_generator< Type >::switch_statement(), exprtk::parser< T >::expression_generator< Type >::synthesize_csocs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csrocs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csrocsr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_uvouv_expression(), exprtk::parser< T >::expression_generator< Type >::vararg_function(), and exprtk::parser< T >::expression_generator< Type >::vararg_function_call().

Here is the call graph for this function:

Here is the caller graph for this function:

free_all_nodes() [2/2]

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 )

inline

Definition at line 6162 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            free_node(node_allocator,b[i]);
         }
 
         b.clear();
      }

References free_node().

Here is the call graph for this function:

free_node()

template<typename NodeAllocator, typename T>

void exprtk::details::free_node ( NodeAllocator & , expression_node< T > *& node )

inline

Definition at line 6173 of file exprtk.hpp.

      {
         if ((0 == node) || is_variable_node(node) || is_string_node(node))
         {
            return;
         }
 
         node_collection_destructor<expression_node<T> >
            ::delete_nodes(node);
      }

References is_string_node(), and is_variable_node().

Referenced by exprtk::parser< T >::expression_generator< Type >::assert_call(), exprtk::parser< T >::expression_generator< Type >::conditional(), exprtk::parser< T >::expression_generator< Type >::conditional_string(), exprtk::parser< T >::expression_generator< Type >::conditional_vector(), exprtk::parser< T >::expression_generator< Type >::const_optimise_mswitch(), exprtk::parser< T >::expression_generator< Type >::const_optimise_sf3(), exprtk::parser< T >::expression_generator< Type >::const_optimise_sf4(), exprtk::parser< T >::expression_generator< Type >::const_optimise_varargfunc(), exprtk::parser< T >::expression_generator< Type >::for_loop(), free_all_nodes(), free_all_nodes(), exprtk::parser< T >::expression_generator< Type >::function(), exprtk::parser< T >::expression_generator< Type >::generic_function_call(), exprtk::parser< Type >::parse_branch(), exprtk::parser< Type >::parse_define_vector_statement(), exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_coboc_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_cocob_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_cocov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_cov_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covoc_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covoc_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_voc_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vococ_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovoc_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovoc_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression4::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression0::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression1::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression2::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression3::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression4::process(), exprtk::parser< T >::expression_generator< Type >::repeat_until_loop(), exprtk::parser< T >::expression_generator< Type >::return_call(), exprtk::parser< T >::expression_generator< Type >::string_function_call(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csocs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csocsr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csos_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csosr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csros_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_csrosr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_null_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_shortcircuit_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_socs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_socsr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_sosr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_srocs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_srocsr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_sros_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_srosr_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_swap_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_vecarithmetic_operation_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_veceqineqlogic_operation_expression(), exprtk::parser< T >::expression_generator< Type >::vararg_function(), exprtk::parser< T >::expression_generator< Type >::vararg_function_call(), exprtk::parser< T >::expression_generator< Type >::vector_element(), and exprtk::parser< T >::expression_generator< Type >::while_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

front()

const char_t & exprtk::details::front ( const std::string & s )

inline

Definition at line 267 of file exprtk.hpp.

      {
         return s[0];
      }

Referenced by exprtk::function_compositor< T >::compile_expression().

Here is the caller graph for this function:

hex_to_bin()

uchar_t exprtk::details::hex_to_bin ( uchar_t h )

inline

Definition at line 319 of file exprtk.hpp.

      {
         if (('0' <= h) && (h <= '9'))
            return (h - '0');
         else
            return static_cast<uchar_t>(std::toupper(h) - 'A' + 10);
      }

Referenced by parse_hex().

Here is the caller graph for this function:

imatch() [1/2]

bool exprtk::details::imatch ( const char_t c1, const char_t c2 )

inline

Definition at line 190 of file exprtk.hpp.

      {
         return std::tolower(c1) == std::tolower(c2);
      }

Referenced by exprtk::parser< T >::scope_element_manager::add_element(), exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), exprtk::parser< T >::scope_element_manager::get_active_element(), exprtk::parser< T >::scope_element_manager::get_element(), is_base_function(), is_control_struct(), is_logic_opr(), is_reserved_symbol(), is_reserved_word(), is_valid_sf_symbol(), exprtk::rtl::vecops::sort< T >::operator()(), exprtk::parser< Type >::parse_assert_statement(), exprtk::parser< Type >::parse_conditional_statement_02(), exprtk::parser< Type >::parse_define_var_statement(), exprtk::parser< Type >::parse_expression(), exprtk::parser< Type >::parse_for_loop(), exprtk::parser< Type >::parse_multi_switch_statement(), exprtk::parser< Type >::parse_repeat_until_loop(), exprtk::parser< Type >::parse_return_statement(), exprtk::parser< Type >::parse_swap_statement(), exprtk::parser< Type >::parse_switch_statement(), exprtk::parser< Type >::parse_symbol(), exprtk::parser< Type >::parse_symtab_symbol(), exprtk::parser< Type >::parse_vararg_function(), exprtk::parser< Type >::parse_vector(), exprtk::lexer::parser_helper::peek_token_is(), expression_processor< T >::process_function_definition(), exprtk::lexer::generator::scan_special_function(), exprtk::lexer::parser_helper::token_is(), exprtk::lexer::parser_helper::token_is(), truth_table_generator(), and exprtk::parser< Type >::valid_vararg_operation().

Here is the caller graph for this function:

imatch() [2/2]

bool exprtk::details::imatch ( const std::string & s1, const std::string & s2 )

inline

Definition at line 195 of file exprtk.hpp.

      {
         if (s1.size() == s2.size())
         {
            for (std::size_t i = 0; i < s1.size(); ++i)
            {
               if (std::tolower(s1[i]) != std::tolower(s2[i]))
               {
                  return false;
               }
            }
 
            return true;
         }
 
         return false;
      }

init_branches()

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

inline

Definition at line 6819 of file exprtk.hpp.

      {
         construct_branch_pair(branch, b0, 0);
         construct_branch_pair(branch, b1, 1);
         construct_branch_pair(branch, b2, 2);
         construct_branch_pair(branch, b3, 3);
         construct_branch_pair(branch, b4, 4);
         construct_branch_pair(branch, b5, 5);
         construct_branch_pair(branch, b6, 6);
         construct_branch_pair(branch, b7, 7);
         construct_branch_pair(branch, b8, 8);
         construct_branch_pair(branch, b9, 9);
      }

References construct_branch_pair().

Referenced by exprtk::details::binary_ext_node< T, Operation >::binary_ext_node(), exprtk::details::binary_node< T >::binary_node(), exprtk::details::quaternary_node< T >::quaternary_node(), and exprtk::details::trinary_node< T >::trinary_node().

Here is the call graph for this function:

Here is the caller graph for this function:

is_assert_node()

template<typename T>

bool exprtk::details::is_assert_node ( const expression_node< T > * node )

inline

Definition at line 6012 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_assert == node->type());
      }

References exprtk::details::expression_node< T >::e_assert, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_assert(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

is_base_function()

bool exprtk::details::is_base_function ( const std::string & function_name )

inline

Definition at line 549 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < base_function_list_size; ++i)
         {
            if (imatch(function_name, base_function_list[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References base_function_list, base_function_list_size, and imatch().

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

is_binary_node()

template<typename T>

bool exprtk::details::is_binary_node ( const expression_node< T > * node )

inline

Definition at line 5821 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_binary == node->type());
      }

References exprtk::details::expression_node< T >::e_binary, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_binary(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

is_block_node()

template<typename T>

bool exprtk::details::is_block_node ( const expression_node< T > * node )

inline

Definition at line 19306 of file exprtk.hpp.

      {
         if (node)
         {
            if (is_loop_node(node))
            {
               return true;
            }
 
            switch (node->type())
            {
               case expression_node<T>::e_conditional :
               case expression_node<T>::e_mswitch     :
               case expression_node<T>::e_switch      :
               case expression_node<T>::e_vararg      : return true;
               default                                : return false;
            }
         }
 
         return false;
      }

References exprtk::details::expression_node< T >::e_conditional, exprtk::details::expression_node< T >::e_mswitch, exprtk::details::expression_node< T >::e_switch, exprtk::details::expression_node< T >::e_vararg, is_loop_node(), and exprtk::details::expression_node< T >::type().

Here is the call graph for this function:

is_boc_node()

template<typename T>

bool exprtk::details::is_boc_node ( const expression_node< T > * node )

inline

Definition at line 19174 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const boc_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::coboc_optimisable(), exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression::process(), and exprtk::parser< T >::expression_generator< Type >::synthesize_coboc_expression::process().

Here is the caller graph for this function:

is_bracket()

bool exprtk::details::is_bracket ( const char_t c )

inline

Definition at line 152 of file exprtk.hpp.

      {
         return is_left_bracket(c) || is_right_bracket(c);
      }

References is_left_bracket(), and is_right_bracket().

Referenced by exprtk::lexer::helper::bracket_checker::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

is_break_node()

template<typename T>

bool exprtk::details::is_break_node ( const expression_node< T > * node )

inline

Definition at line 5963 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_break == node->type());
      }

References exprtk::details::expression_node< T >::e_break, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_break_continue_op(), and exprtk::parser< T >::expression_generator< Type >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

is_cob_node()

template<typename T>

bool exprtk::details::is_cob_node ( const expression_node< T > * node )

inline

Definition at line 19168 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const cob_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::cocob_optimisable(), exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression::process(), and exprtk::parser< T >::expression_generator< Type >::synthesize_cocob_expression::process().

Here is the caller graph for this function:

is_const_string_node()

template<typename T>

bool exprtk::details::is_const_string_node ( const expression_node< T > * node )

inline

Definition at line 19210 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringconst == node->type());
      }

References exprtk::details::expression_node< T >::e_stringconst, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< Type >::parse_assert_statement(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_const_string_range_node()

template<typename T>

bool exprtk::details::is_const_string_range_node ( const expression_node< T > * node )

inline

Definition at line 19216 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_cstringvarrng == node->type());
      }

References exprtk::details::expression_node< T >::e_cstringvarrng, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::details::generic_function_node< T, StringFunction >::init_branches(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_constant_node()

template<typename T>

bool exprtk::details::is_constant_node ( const expression_node< T > * node )

inline

Definition at line 5947 of file exprtk.hpp.

      {
         return node &&
         (
           details::expression_node<T>::e_constant    == node->type() ||
           details::expression_node<T>::e_stringconst == node->type()
         );
      }

References exprtk::details::expression_node< T >::e_constant, exprtk::details::expression_node< T >::e_stringconst, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::binext_optimisable(), exprtk::parser< T >::expression_generator< Type >::boc_optimisable(), exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< T >::expression_generator< Type >::cob_optimisable(), exprtk::parser< T >::expression_generator< Type >::coboc_optimisable(), exprtk::parser< T >::expression_generator< Type >::cocob_optimisable(), exprtk::parser< T >::expression_generator< Type >::conditional(), exprtk::parser< T >::expression_generator< Type >::conditional_string(), exprtk::parser< T >::expression_generator< Type >::conditional_vector(), exprtk::parser< T >::expression_generator< Type >::cov_optimisable(), exprtk::parser< T >::expression_generator< Type >::for_loop(), exprtk::parser< T >::expression_generator< Type >::function(), exprtk::parser< T >::expression_generator< Type >::is_constant_foldable(), exprtk::parser< T >::expression_generator< Type >::is_constant_foldable(), exprtk::parser< T >::expression_generator< Type >::is_constpow_operation(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< Type >::parse_define_vector_statement(), exprtk::parser< T >::expression_generator< Type >::repeat_until_loop(), exprtk::parser< T >::expression_generator< Type >::synthesize_shortcircuit_expression(), exprtk::parser< Type >::synthesize_vector_element(), exprtk::details::vector_init_iota_constconst_node< T >::valid(), exprtk::details::vector_init_iota_constnconst_node< T >::valid(), exprtk::details::vector_init_iota_nconstconst_node< T >::valid(), exprtk::details::vector_init_iota_nconstnconst_node< T >::valid(), exprtk::details::vector_init_single_constvalue_node< T >::valid(), exprtk::details::vector_init_single_value_node< T >::valid(), exprtk::parser< T >::expression_generator< Type >::vector_element(), exprtk::details::vector_initialisation_node< T >::vector_initialisation_node(), exprtk::parser< T >::expression_generator< Type >::voc_optimisable(), and exprtk::parser< T >::expression_generator< Type >::while_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

is_continue_node()

template<typename T>

bool exprtk::details::is_continue_node ( const expression_node< T > * node )

inline

Definition at line 5969 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_continue == node->type());
      }

References exprtk::details::expression_node< T >::e_continue, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_break_continue_op(), and exprtk::parser< T >::expression_generator< Type >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

is_control_struct()

bool exprtk::details::is_control_struct ( const std::string & cntrl_strct )

inline

Definition at line 562 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < cntrl_struct_list_size; ++i)
         {
            if (imatch(cntrl_strct, cntrl_struct_list[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References cntrl_struct_list, cntrl_struct_list_size, and imatch().

Here is the call graph for this function:

is_cov_node()

template<typename T>

bool exprtk::details::is_cov_node ( const expression_node< T > * node )

inline

Definition at line 19156 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const cov_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the caller graph for this function:

is_digit()

bool exprtk::details::is_digit ( const char_t c )

inline

Definition at line 132 of file exprtk.hpp.

      {
         return ('0' <= c) && (c <= '9');
      }

Referenced by is_invalid(), is_letter_or_digit(), is_valid_sf_symbol(), exprtk::lexer::generator::next_is_digit(), exprtk::parser< Type >::parse_special_function(), exprtk::lexer::generator::scan_number(), exprtk::lexer::generator::scan_special_function(), and exprtk::lexer::generator::scan_token().

Here is the caller graph for this function:

is_false() [1/5]

bool exprtk::details::is_false ( const cmplx::complex_t & v )

inline

Definition at line 375 of file exprtk_complex_adaptor.hpp.

{ return cmplx::is_false(v); }

References cmplx::is_false().

Here is the call graph for this function:

is_false() [2/5]

template<typename T>

bool exprtk::details::is_false ( const expression_node< T > * node )

inline

Definition at line 5791 of file exprtk.hpp.

      {
         return std::equal_to<T>()(T(0),node->value());
      }

References exprtk::details::expression_node< T >::value().

Referenced by exprtk::details::repeat_until_loop_bc_node< T >::value(), exprtk::details::repeat_until_loop_bc_rtc_node< T >::value(), exprtk::details::repeat_until_loop_node< T >::value(), and exprtk::details::repeat_until_loop_rtc_node< T >::value().

Here is the call graph for this function:

Here is the caller graph for this function:

is_false() [3/5]

bool exprtk::details::is_false ( const mpfr::mpreal & v )

inline

Definition at line 383 of file exprtk_mpfr_adaptor.hpp.

{ return details::numeric::details::is_false_impl(v); }

References exprtk::details::numeric::details::is_false_impl().

Here is the call graph for this function:

is_false() [4/5]

bool exprtk::details::is_false ( const real::type v )

inline

Definition at line 358 of file exprtk_real_adaptor.hpp.

{ return real::is_false(v); }

References real::is_false().

Here is the call graph for this function:

is_false() [5/5]

template<typename T>

bool exprtk::details::is_false ( const std::pair< expression_node< T > *, bool > & node )

inline

Definition at line 5797 of file exprtk.hpp.

      {
         return std::equal_to<T>()(T(0),node.first->value());
      }

is_function()

template<typename T>

bool exprtk::details::is_function ( const expression_node< T > * node )

inline

Definition at line 5981 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_function == node->type());
      }

References exprtk::details::expression_node< T >::e_function, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_function(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

is_generally_string_node()

template<typename T>

bool exprtk::details::is_generally_string_node ( const expression_node< T > * node )

inline

Definition at line 19264 of file exprtk.hpp.

      {
         if (node)
         {
            switch (node->type())
            {
               case expression_node<T>::e_stringvar     :
               case expression_node<T>::e_stringconst   :
               case expression_node<T>::e_stringvarrng  :
               case expression_node<T>::e_cstringvarrng :
               case expression_node<T>::e_strgenrange   :
               case expression_node<T>::e_strass        :
               case expression_node<T>::e_strconcat     :
               case expression_node<T>::e_strfunction   :
               case expression_node<T>::e_strcondition  :
               case expression_node<T>::e_strccondition :
               case expression_node<T>::e_stringvararg  : return true;
               default                                  : return false;
            }
         }
 
         return false;
      }

References exprtk::details::expression_node< T >::e_cstringvarrng, exprtk::details::expression_node< T >::e_strass, exprtk::details::expression_node< T >::e_strccondition, exprtk::details::expression_node< T >::e_strconcat, exprtk::details::expression_node< T >::e_strcondition, exprtk::details::expression_node< T >::e_strfunction, exprtk::details::expression_node< T >::e_strgenrange, exprtk::details::expression_node< T >::e_stringconst, exprtk::details::expression_node< T >::e_stringvar, exprtk::details::expression_node< T >::e_stringvararg, exprtk::details::expression_node< T >::e_stringvarrng, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assert_node< T >::assert_node(), exprtk::details::assignment_string_node< T, AssignmentProcess >::assignment_string_node(), exprtk::details::assignment_string_range_node< T, AssignmentProcess >::assignment_string_range_node(), exprtk::details::conditional_string_node< T >::conditional_string_node(), exprtk::details::cons_conditional_str_node< T >::cons_conditional_str_node(), exprtk::details::generic_string_range_node< T >::generic_string_range_node(), exprtk::details::generic_function_node< T, StringFunction >::init_branches(), exprtk::parser< T >::expression_generator< Type >::is_constpow_operation(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::expression_helper< T >::is_string(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< Type >::parse_assert_statement(), exprtk::parser< Type >::parse_define_var_statement(), exprtk::parser< Type >::post_bracket_process(), exprtk::details::str_sogens_node< T, Operation >::str_sogens_node(), exprtk::details::str_vararg_node< T, VarArgFunction >::str_vararg_node(), exprtk::details::string_concat_node< T >::string_concat_node(), exprtk::details::string_size_node< T >::string_size_node(), exprtk::details::swap_genstrings_node< T >::swap_genstrings_node(), exprtk::parser< T >::expression_generator< Type >::synthesize_swap_expression(), and exprtk::details::assert_node< T >::valid().

Here is the call graph for this function:

Here is the caller graph for this function:

is_genricstring_range_node()

template<typename T>

bool exprtk::details::is_genricstring_range_node ( const expression_node< T > * node )

inline

Definition at line 19258 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strgenrange == node->type());
      }

References exprtk::details::expression_node< T >::e_strgenrange, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_hex_digit()

bool exprtk::details::is_hex_digit ( const uchar_t digit )

inline

Definition at line 312 of file exprtk.hpp.

      {
         return (('0' <= digit) && (digit <= '9')) ||
                (('A' <= digit) && (digit <= 'F')) ||
                (('a' <= digit) && (digit <= 'f')) ;
      }

Referenced by parse_hex(), and exprtk::lexer::generator::scan_string().

Here is the caller graph for this function:

is_invalid()

bool exprtk::details::is_invalid ( const char_t c )

inline

Definition at line 162 of file exprtk.hpp.

      {
         return !is_whitespace   (c) &&
                !is_operator_char(c) &&
                !is_letter       (c) &&
                !is_digit        (c) &&
                ('.'  != c)          &&
                ('_'  != c)          &&
                ('$'  != c)          &&
                ('~'  != c)          &&
                ('\'' != c);
      }

References is_digit(), is_letter(), is_operator_char(), and is_whitespace().

Referenced by exprtk::lexer::generator::skip_comments().

Here is the call graph for this function:

Here is the caller graph for this function:

is_ivariable_node()

template<typename T>

bool exprtk::details::is_ivariable_node ( const expression_node< T > * node )

inline

Definition at line 5833 of file exprtk.hpp.

      {
         return node &&
                (
                  details::expression_node<T>::e_variable      == node->type() ||
                  details::expression_node<T>::e_vecelem       == node->type() ||
                  details::expression_node<T>::e_veccelem      == node->type() ||
                  details::expression_node<T>::e_vecelemrtc    == node->type() ||
                  details::expression_node<T>::e_veccelemrtc   == node->type() ||
                  details::expression_node<T>::e_rbvecelem     == node->type() ||
                  details::expression_node<T>::e_rbveccelem    == node->type() ||
                  details::expression_node<T>::e_rbvecelemrtc  == node->type() ||
                  details::expression_node<T>::e_rbveccelemrtc == node->type()
                );
      }

References exprtk::details::expression_node< T >::e_rbveccelem, exprtk::details::expression_node< T >::e_rbveccelemrtc, exprtk::details::expression_node< T >::e_rbvecelem, exprtk::details::expression_node< T >::e_rbvecelemrtc, exprtk::details::expression_node< T >::e_variable, exprtk::details::expression_node< T >::e_veccelem, exprtk::details::expression_node< T >::e_veccelemrtc, exprtk::details::expression_node< T >::e_vecelem, exprtk::details::expression_node< T >::e_vecelemrtc, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_swap_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_ivector_node()

template<typename T>

bool exprtk::details::is_ivector_node ( const expression_node< T > * node )

inline

Definition at line 5904 of file exprtk.hpp.

      {
         if (node)
         {
            switch (node->type())
            {
               case details::expression_node<T>::e_vector      :
               case details::expression_node<T>::e_vecvalass   :
               case details::expression_node<T>::e_vecvecass   :
               case details::expression_node<T>::e_vecopvalass :
               case details::expression_node<T>::e_vecopvecass :
               case details::expression_node<T>::e_vecvecswap  :
               case details::expression_node<T>::e_vecvecarith :
               case details::expression_node<T>::e_vecvalarith :
               case details::expression_node<T>::e_valvecarith :
               case details::expression_node<T>::e_vecunaryop  :
               case details::expression_node<T>::e_vecondition : return true;
               default                                         : return false;
            }
         }
         else
            return false;
      }

References exprtk::details::expression_node< T >::e_valvecarith, exprtk::details::expression_node< T >::e_vecondition, exprtk::details::expression_node< T >::e_vecopvalass, exprtk::details::expression_node< T >::e_vecopvecass, exprtk::details::expression_node< T >::e_vector, exprtk::details::expression_node< T >::e_vecunaryop, exprtk::details::expression_node< T >::e_vecvalarith, exprtk::details::expression_node< T >::e_vecvalass, exprtk::details::expression_node< T >::e_vecvecarith, exprtk::details::expression_node< T >::e_vecvecass, exprtk::details::expression_node< T >::e_vecvecswap, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vecvec_node< T >::assignment_vecvec_node(), exprtk::details::assignment_vecvec_op_node< T, Operation >::assignment_vecvec_op_node(), exprtk::details::conditional_vector_node< T >::conditional_vector_node(), exprtk::details::generic_function_node< T, StringFunction >::init_branches(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< Type >::post_bracket_process(), exprtk::details::swap_vecvec_node< T >::swap_vecvec_node(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_swap_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_vecarithmetic_operation_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_veceqineqlogic_operation_expression(), exprtk::details::unary_vector_node< T, Operation >::unary_vector_node(), exprtk::parser< T >::expression_generator< Type >::vararg_function(), exprtk::details::vec_binop_valvec_node< T, Operation >::vec_binop_valvec_node(), exprtk::details::vec_binop_vecval_node< T, Operation >::vec_binop_vecval_node(), exprtk::details::vec_binop_vecvec_node< T, Operation >::vec_binop_vecvec_node(), exprtk::parser< T >::expression_generator< Type >::vector_element(), and exprtk::details::vectorize_node< T, VecFunction >::vectorize_node().

Here is the call graph for this function:

Here is the caller graph for this function:

is_left_bracket()

bool exprtk::details::is_left_bracket ( const char_t c )

inline

Definition at line 142 of file exprtk.hpp.

      {
         return ('(' == c) || ('[' == c) || ('{' == c);
      }

Referenced by exprtk::lexer::helper::sequence_validator::invalid_bracket_check(), and is_bracket().

Here is the caller graph for this function:

is_letter()

bool exprtk::details::is_letter ( const char_t c )

inline

Definition at line 126 of file exprtk.hpp.

      {
         return (('a' <= c) && (c <= 'z')) ||
                (('A' <= c) && (c <= 'Z')) ;
      }

Referenced by is_invalid(), is_letter_or_digit(), exprtk::lexer::generator::scan_token(), exprtk::symbol_table< T >::valid_function(), and exprtk::symbol_table< T >::valid_symbol().

Here is the caller graph for this function:

is_letter_or_digit()

bool exprtk::details::is_letter_or_digit ( const char_t c )

inline

Definition at line 137 of file exprtk.hpp.

      {
         return is_letter(c) || is_digit(c);
      }

References is_digit(), and is_letter().

Referenced by exprtk::lexer::generator::scan_symbol(), exprtk::symbol_table< T >::valid_function(), and exprtk::symbol_table< T >::valid_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

is_literal_node()

template<typename T>

bool exprtk::details::is_literal_node ( const expression_node< T > * node )

inline

Definition at line 5803 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_constant == node->type());
      }

References exprtk::details::expression_node< T >::e_constant, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::expression_helper< T >::is_literal(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< Type >::parse_define_constvar_statement(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_logic_opr()

bool exprtk::details::is_logic_opr ( const std::string & lgc_opr )

inline

Definition at line 575 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < logic_ops_list_size; ++i)
         {
            if (imatch(lgc_opr, logic_ops_list[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References imatch(), logic_ops_list, and logic_ops_list_size.

Referenced by exprtk::parser< Type >::parse_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_loop_node()

template<typename T>

bool exprtk::details::is_loop_node ( const expression_node< T > * node )

inline

Definition at line 19289 of file exprtk.hpp.

      {
         if (node)
         {
            switch (node->type())
            {
               case expression_node<T>::e_for    :
               case expression_node<T>::e_repeat :
               case expression_node<T>::e_while  : return true;
               default                           : return false;
            }
         }
 
         return false;
      }

References exprtk::details::expression_node< T >::e_for, exprtk::details::expression_node< T >::e_repeat, exprtk::details::expression_node< T >::e_while, and exprtk::details::expression_node< T >::type().

Referenced by is_block_node().

Here is the call graph for this function:

Here is the caller graph for this function:

is_neg_unary_node()

template<typename T>

bool exprtk::details::is_neg_unary_node ( const expression_node< T > * node )

inline

Definition at line 5815 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_neg == node->type());
      }

References exprtk::details::expression_node< T >::e_neg, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< Type >::parse_branch().

Here is the call graph for this function:

Here is the caller graph for this function:

is_negate_node()

template<typename T>

bool exprtk::details::is_negate_node ( const expression_node< T > * node )

inline

Definition at line 6001 of file exprtk.hpp.

      {
         if (node && is_unary_node(node))
         {
            return (details::e_neg == static_cast<const unary_node<T>*>(node)->operation());
         }
         else
            return false;
      }

References e_neg, and is_unary_node().

Here is the call graph for this function:

is_null_node()

template<typename T>

bool exprtk::details::is_null_node ( const expression_node< T > * node )

inline

Definition at line 5957 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_null == node->type());
      }

References exprtk::details::expression_node< T >::e_null, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< T >::expression_generator< Type >::for_loop(), exprtk::expression_helper< T >::is_null(), exprtk::parser< T >::expression_generator< Type >::is_null_present(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::repeat_until_loop(), exprtk::parser< T >::expression_generator< Type >::synthesize_null_expression(), and exprtk::parser< T >::expression_generator< Type >::while_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

is_operator_char()

bool exprtk::details::is_operator_char ( const char_t c )

inline

Definition at line 111 of file exprtk.hpp.

      {
         return ('+' == c) || ('-' == c) ||
                ('*' == c) || ('/' == c) ||
                ('^' == c) || ('<' == c) ||
                ('>' == c) || ('=' == c) ||
                (',' == c) || ('!' == c) ||
                ('(' == c) || (')' == c) ||
                ('[' == c) || (']' == c) ||
                ('{' == c) || ('}' == c) ||
                ('%' == c) || (':' == c) ||
                ('?' == c) || ('&' == c) ||
                ('|' == c) || (';' == c) ;
      }

Referenced by is_invalid(), and exprtk::lexer::generator::scan_token().

Here is the caller graph for this function:

is_rebasevector_celem_node()

template<typename T>

bool exprtk::details::is_rebasevector_celem_node ( const expression_node< T > * node )

inline

Definition at line 5892 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbveccelem == node->type());
      }

References exprtk::details::expression_node< T >::e_rbveccelem, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_celem_node< T >::assignment_rebasevec_celem_node(), exprtk::details::assignment_rebasevec_celem_op_node< T, Operation >::assignment_rebasevec_celem_op_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_rebasevector_celem_rtc_node()

template<typename T>

bool exprtk::details::is_rebasevector_celem_rtc_node ( const expression_node< T > * node )

inline

Definition at line 5886 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbveccelemrtc == node->type());
      }

References exprtk::details::expression_node< T >::e_rbveccelemrtc, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_celem_op_rtc_node< T, Operation >::assignment_rebasevec_celem_op_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_rebasevector_elem_node()

template<typename T>

bool exprtk::details::is_rebasevector_elem_node ( const expression_node< T > * node )

inline

Definition at line 5874 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbvecelem == node->type());
      }

References exprtk::details::expression_node< T >::e_rbvecelem, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_elem_node< T >::assignment_rebasevec_elem_node(), exprtk::details::assignment_rebasevec_elem_op_node< T, Operation >::assignment_rebasevec_elem_op_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_rebasevector_elem_rtc_node()

template<typename T>

bool exprtk::details::is_rebasevector_elem_rtc_node ( const expression_node< T > * node )

inline

Definition at line 5880 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbvecelemrtc == node->type());
      }

References exprtk::details::expression_node< T >::e_rbvecelemrtc, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_elem_op_rtc_node< T, Operation >::assignment_rebasevec_elem_op_rtc_node(), exprtk::details::assignment_rebasevec_elem_rtc_node< T >::assignment_rebasevec_elem_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_reserved_symbol()

bool exprtk::details::is_reserved_symbol ( const std::string & symbol )

inline

Definition at line 536 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < reserved_symbols_size; ++i)
         {
            if (imatch(symbol, reserved_symbols[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References imatch(), reserved_symbols, and reserved_symbols_size.

Referenced by exprtk::parser< Type >::parse_define_constvar_statement(), exprtk::parser< Type >::parse_define_var_statement(), and exprtk::parser< Type >::parse_symtab_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

is_reserved_word()

bool exprtk::details::is_reserved_word ( const std::string & symbol )

inline

Definition at line 523 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < reserved_words_size; ++i)
         {
            if (imatch(symbol, reserved_words[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References imatch(), reserved_words, and reserved_words_size.

Referenced by exprtk::parser< Type >::remove_replace_symbol(), and exprtk::parser< Type >::replace_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

is_return_node()

template<typename T>

bool exprtk::details::is_return_node ( const expression_node< T > * node )

inline

Definition at line 5993 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_return == node->type());
      }

References exprtk::details::expression_node< T >::e_return, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< Type >::parse_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_right_bracket()

bool exprtk::details::is_right_bracket ( const char_t c )

inline

Definition at line 147 of file exprtk.hpp.

      {
         return (')' == c) || (']' == c) || ('}' == c);
      }

Referenced by exprtk::lexer::helper::sequence_validator::invalid_bracket_check(), is_bracket(), and exprtk::lexer::helper::bracket_checker::operator()().

Here is the caller graph for this function:

is_sf3ext_node()

template<typename T>

bool exprtk::details::is_sf3ext_node ( const expression_node< T > * n )

inline

Definition at line 17935 of file exprtk.hpp.

      {
         switch (n->type())
         {
            case expression_node<T>::e_vovov : return true;
            case expression_node<T>::e_vovoc : return true;
            case expression_node<T>::e_vocov : return true;
            case expression_node<T>::e_covov : return true;
            case expression_node<T>::e_covoc : return true;
            default                          : return false;
         }
      }

References exprtk::details::expression_node< T >::e_covoc, exprtk::details::expression_node< T >::e_covov, exprtk::details::expression_node< T >::e_vocov, exprtk::details::expression_node< T >::e_vovoc, exprtk::details::expression_node< T >::e_vovov, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_sf4ext_expression::compile_left(), exprtk::parser< T >::expression_generator< Type >::synthesize_sf4ext_expression::compile_right(), exprtk::expression_helper< T >::is_sf3ext(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression::process(), and exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression::process().

Here is the call graph for this function:

Here is the caller graph for this function:

is_sf4ext_node()

template<typename T>

bool exprtk::details::is_sf4ext_node ( const expression_node< T > * n )

inline

Definition at line 18113 of file exprtk.hpp.

      {
         switch (n->type())
         {
            case expression_node<T>::e_vovovov : return true;
            case expression_node<T>::e_vovovoc : return true;
            case expression_node<T>::e_vovocov : return true;
            case expression_node<T>::e_vocovov : return true;
            case expression_node<T>::e_covovov : return true;
            case expression_node<T>::e_covocov : return true;
            case expression_node<T>::e_vocovoc : return true;
            case expression_node<T>::e_covovoc : return true;
            case expression_node<T>::e_vococov : return true;
            default                            : return false;
         }
      }

References exprtk::details::expression_node< T >::e_covocov, exprtk::details::expression_node< T >::e_covovoc, exprtk::details::expression_node< T >::e_covovov, exprtk::details::expression_node< T >::e_vococov, exprtk::details::expression_node< T >::e_vocovoc, exprtk::details::expression_node< T >::e_vocovov, exprtk::details::expression_node< T >::e_vovocov, exprtk::details::expression_node< T >::e_vovovoc, exprtk::details::expression_node< T >::e_vovovov, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_sf4ext(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

is_sign()

bool exprtk::details::is_sign ( const char_t c )

inline

Definition at line 157 of file exprtk.hpp.

      {
         return ('+' == c) || ('-' == c);
      }

Referenced by exprtk::lexer::generator::scan_number().

Here is the caller graph for this function:

is_string_assignment_node()

template<typename T>

bool exprtk::details::is_string_assignment_node ( const expression_node< T > * node )

inline

Definition at line 19222 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strass == node->type());
      }

References exprtk::details::expression_node< T >::e_strass, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_ccondition_node()

template<typename T>

bool exprtk::details::is_string_ccondition_node ( const expression_node< T > * node )

inline

Definition at line 19246 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strccondition == node->type());
      }

References exprtk::details::expression_node< T >::e_strccondition, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_concat_node()

template<typename T>

bool exprtk::details::is_string_concat_node ( const expression_node< T > * node )

inline

Definition at line 19228 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strconcat == node->type());
      }

References exprtk::details::expression_node< T >::e_strconcat, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_condition_node()

template<typename T>

bool exprtk::details::is_string_condition_node ( const expression_node< T > * node )

inline

Definition at line 19240 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strcondition == node->type());
      }

References exprtk::details::expression_node< T >::e_strcondition, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_function_node()

template<typename T>

bool exprtk::details::is_string_function_node ( const expression_node< T > * node )

inline

Definition at line 19234 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strfunction == node->type());
      }

References exprtk::details::expression_node< T >::e_strfunction, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_node()

template<typename T>

bool exprtk::details::is_string_node ( const expression_node< T > * node )

inline

Definition at line 19198 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringvar == node->type());
      }

References exprtk::details::expression_node< T >::e_stringvar, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_string_node< T, AssignmentProcess >::assignment_string_node(), branch_deletable(), exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::details::range_pack< T >::free(), free_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::details::swap_string_node< T >::swap_string_node(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_range_node()

template<typename T>

bool exprtk::details::is_string_range_node ( const expression_node< T > * node )

inline

Definition at line 19204 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringvarrng == node->type());
      }

References exprtk::details::expression_node< T >::e_stringvarrng, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_string_range_node< T, AssignmentProcess >::assignment_string_range_node(), exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_string_vararg_node()

template<typename T>

bool exprtk::details::is_string_vararg_node ( const expression_node< T > * node )

inline

Definition at line 19252 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringvararg == node->type());
      }

References exprtk::details::expression_node< T >::e_stringvararg, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_swap_node()

template<typename T>

bool exprtk::details::is_swap_node ( const expression_node< T > * node )

inline

Definition at line 5975 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_swap == node->type());
      }

References exprtk::details::expression_node< T >::e_swap, and exprtk::details::expression_node< T >::type().

Here is the call graph for this function:

is_t0ot1ot2_node()

template<typename T>

bool exprtk::details::is_t0ot1ot2_node ( const expression_node< T > * node )

inline

Definition at line 19180 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const T0oT1oT2_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the caller graph for this function:

is_t0ot1ot2ot3_node()

template<typename T>

bool exprtk::details::is_t0ot1ot2ot3_node ( const expression_node< T > * node )

inline

Definition at line 19186 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const T0oT1oT2oT3_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the caller graph for this function:

is_true() [1/8]

bool exprtk::details::is_true ( const cmplx::complex_t & v )

inline

Definition at line 374 of file exprtk_complex_adaptor.hpp.

{ return cmplx::is_true(v);  }

References cmplx::is_true().

Here is the call graph for this function:

is_true() [2/8]

bool exprtk::details::is_true ( const double v )

inline

Definition at line 5763 of file exprtk.hpp.

      {
         return std::not_equal_to<double>()(0.0,v);
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::conditional(), exprtk::parser< T >::expression_generator< Type >::conditional_string(), exprtk::parser< T >::expression_generator< Type >::conditional_vector(), exprtk::parser< T >::expression_generator< Type >::const_optimise_mswitch(), exprtk::parser< T >::expression_generator< Type >::const_optimise_switch(), exprtk::parser< T >::expression_generator< Type >::for_loop(), exprtk::details::sf47_op< T >::id(), exprtk::details::sf92_op< T >::id(), exprtk::details::sf93_op< T >::id(), exprtk::details::sf98_op< T >::id(), exprtk::symtab_list_t< T >::operator bool(), pgo_primer(), exprtk::details::and_op< T >::process(), exprtk::details::nand_op< T >::process(), exprtk::details::nor_op< T >::process(), exprtk::details::or_op< T >::process(), exprtk::parser< T >::expression_generator< Type >::repeat_until_loop(), exprtk::details::assert_node< T >::value(), exprtk::details::conditional_node< T >::value(), exprtk::details::conditional_string_node< T >::value(), exprtk::details::conditional_vector_node< T >::value(), exprtk::details::cons_conditional_node< T >::value(), exprtk::details::cons_conditional_str_node< T >::value(), exprtk::details::for_loop_bc_node< T >::value(), exprtk::details::for_loop_bc_rtc_node< T >::value(), exprtk::details::for_loop_node< T >::value(), exprtk::details::for_loop_rtc_node< T >::value(), exprtk::details::multi_switch_node< T >::value(), exprtk::details::switch_node< T >::value(), exprtk::details::while_loop_bc_node< T >::value(), exprtk::details::while_loop_bc_rtc_node< T >::value(), exprtk::details::while_loop_node< T >::value(), exprtk::details::while_loop_rtc_node< T >::value(), and exprtk::parser< T >::expression_generator< Type >::while_loop().

Here is the caller graph for this function:

is_true() [3/8]

template<typename T>

bool exprtk::details::is_true ( const expression_node< T > * node )

inline

Definition at line 5779 of file exprtk.hpp.

      {
         return std::not_equal_to<T>()(T(0),node->value());
      }

References exprtk::details::expression_node< T >::value().

Here is the call graph for this function:

is_true() [4/8]

bool exprtk::details::is_true ( const float v )

inline

Definition at line 5773 of file exprtk.hpp.

      {
         return std::not_equal_to<float>()(0.0f,v);
      }

is_true() [5/8]

bool exprtk::details::is_true ( const long double v )

inline

Definition at line 5768 of file exprtk.hpp.

      {
         return std::not_equal_to<long double>()(0.0L,v);
      }

is_true() [6/8]

bool exprtk::details::is_true ( const mpfr::mpreal & v )

inline

Definition at line 382 of file exprtk_mpfr_adaptor.hpp.

{ return details::numeric::details::is_true_impl (v); }

References exprtk::details::numeric::details::is_true_impl().

Here is the call graph for this function:

is_true() [7/8]

bool exprtk::details::is_true ( const real::type v )

inline

Definition at line 357 of file exprtk_real_adaptor.hpp.

{ return real::is_true(v);  }

References real::is_true().

Here is the call graph for this function:

is_true() [8/8]

template<typename T>

bool exprtk::details::is_true ( const std::pair< expression_node< T > *, bool > & node )

inline

Definition at line 5785 of file exprtk.hpp.

      {
         return std::not_equal_to<T>()(T(0),node.first->value());
      }

is_unary_node()

template<typename T>

bool exprtk::details::is_unary_node ( const expression_node< T > * node )

inline

Definition at line 5809 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_unary == node->type());
      }

References exprtk::details::expression_node< T >::e_unary, and exprtk::details::expression_node< T >::type().

Referenced by is_negate_node(), exprtk::expression_helper< T >::is_unary(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

is_uv_node()

template<typename T>

bool exprtk::details::is_uv_node ( const expression_node< T > * node )

inline

Definition at line 19192 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const uv_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression::process(), and exprtk::parser< T >::expression_generator< Type >::uvouv_optimisable().

Here is the caller graph for this function:

is_valid_sf_symbol()

bool exprtk::details::is_valid_sf_symbol ( const std::string & symbol )

inline

Definition at line 257 of file exprtk.hpp.

      {
         // Special function: $f12 or $F34
         return (4 == symbol.size())  &&
                ('$' == symbol[0])    &&
                imatch('f',symbol[1]) &&
                is_digit(symbol[2])   &&
                is_digit(symbol[3]);
      }

References imatch(), and is_digit().

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

is_valid_string_char()

bool exprtk::details::is_valid_string_char ( const char_t c )

inline

Definition at line 175 of file exprtk.hpp.

      {
         return std::isprint(static_cast<uchar_t>(c)) ||
                is_whitespace(c);
      }

References is_whitespace().

Referenced by exprtk::lexer::generator::scan_string().

Here is the call graph for this function:

Here is the caller graph for this function:

is_vararg_node()

template<typename T>

bool exprtk::details::is_vararg_node ( const expression_node< T > * node )

inline

Definition at line 5987 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vararg == node->type());
      }

References exprtk::details::expression_node< T >::e_vararg, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_vararg().

Here is the call graph for this function:

Here is the caller graph for this function:

is_variable_node()

template<typename T>

bool exprtk::details::is_variable_node ( const expression_node< T > * node )

inline

Definition at line 5827 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_variable == node->type());
      }

References exprtk::details::expression_node< T >::e_variable, and exprtk::details::expression_node< T >::type().

Referenced by all_nodes_variables(), all_nodes_variables(), exprtk::details::assignment_node< T >::assignment_node(), exprtk::details::assignment_op_node< T, Operation >::assignment_op_node(), exprtk::parser< T >::expression_generator< Type >::bov_optimisable(), branch_deletable(), exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::details::vararg_function_node< T, VarArgFunction >::collect_nodes(), exprtk::parser< T >::expression_generator< Type >::cov_optimisable(), exprtk::details::range_pack< T >::free(), free_node(), exprtk::parser< T >::scope_element_manager::get_variable(), exprtk::details::generic_function_node< T, StringFunction >::init_branches(), exprtk::parser< T >::expression_generator< Type >::is_constpow_operation(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::expression_helper< T >::is_variable(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::details::vararg_varnode< T, VarArgFunction >::vararg_varnode(), exprtk::parser< T >::expression_generator< Type >::vob_optimisable(), exprtk::parser< T >::expression_generator< Type >::voc_optimisable(), and exprtk::parser< T >::expression_generator< Type >::vov_optimisable().

Here is the call graph for this function:

Here is the caller graph for this function:

is_vector_celem_node()

template<typename T>

bool exprtk::details::is_vector_celem_node ( const expression_node< T > * node )

inline

Definition at line 5856 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_veccelem == node->type());
      }

References exprtk::details::expression_node< T >::e_veccelem, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_vector_celem_rtc_node()

template<typename T>

bool exprtk::details::is_vector_celem_rtc_node ( const expression_node< T > * node )

inline

Definition at line 5868 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_veccelemrtc == node->type());
      }

References exprtk::details::expression_node< T >::e_veccelemrtc, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_celem_op_rtc_node< T, Operation >::assignment_vec_celem_op_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_vector_elem_node()

template<typename T>

bool exprtk::details::is_vector_elem_node ( const expression_node< T > * node )

inline

Definition at line 5850 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vecelem == node->type());
      }

References exprtk::details::expression_node< T >::e_vecelem, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_elem_node< T >::assignment_vec_elem_node(), exprtk::details::assignment_vec_elem_op_node< T, Operation >::assignment_vec_elem_op_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_vector_elem_rtc_node()

template<typename T>

bool exprtk::details::is_vector_elem_rtc_node ( const expression_node< T > * node )

inline

Definition at line 5862 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vecelemrtc == node->type());
      }

References exprtk::details::expression_node< T >::e_vecelemrtc, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_elem_op_rtc_node< T, Operation >::assignment_vec_elem_op_rtc_node(), exprtk::details::assignment_vec_elem_rtc_node< T >::assignment_vec_elem_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

is_vector_node()

template<typename T>

bool exprtk::details::is_vector_node ( const expression_node< T > * node )

inline

Definition at line 5898 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vector == node->type());
      }

References exprtk::details::expression_node< T >::e_vector, and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_node< T >::assignment_vec_node(), exprtk::details::assignment_vec_op_node< T, Operation >::assignment_vec_op_node(), exprtk::details::assignment_vecvec_node< T >::assignment_vecvec_node(), exprtk::details::assignment_vecvec_op_node< T, Operation >::assignment_vecvec_op_node(), exprtk::parser< T >::expression_generator< Type >::is_constpow_operation(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::details::unary_vector_node< T, Operation >::unary_vector_node(), exprtk::details::vec_binop_valvec_node< T, Operation >::vec_binop_valvec_node(), exprtk::details::vec_binop_vecval_node< T, Operation >::vec_binop_vecval_node(), exprtk::details::vec_binop_vecvec_node< T, Operation >::vec_binop_vecvec_node(), and exprtk::parser< T >::expression_generator< Type >::vector_element().

Here is the call graph for this function:

Here is the caller graph for this function:

is_voc_node()

template<typename T>

bool exprtk::details::is_voc_node ( const expression_node< T > * node )

inline

Definition at line 19162 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const voc_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the caller graph for this function:

is_vov_node()

template<typename T>

bool exprtk::details::is_vov_node ( const expression_node< T > * node )

inline

Definition at line 19150 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const vov_base_node<T>*>(node));
      }

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the caller graph for this function:

is_whitespace()

bool exprtk::details::is_whitespace ( const char_t c )

inline

Definition at line 103 of file exprtk.hpp.

      {
         return (' '  == c) || ('\n' == c) ||
                ('\r' == c) || ('\t' == c) ||
                ('\b' == c) || ('\v' == c) ||
                ('\f' == c) ;
      }

Referenced by exprtk::parser< Type >::construct_subexpr(), is_invalid(), is_valid_string_char(), exprtk::lexer::generator::scan_token(), and exprtk::lexer::generator::skip_whitespace().

Here is the caller graph for this function:

load_operations_map()

void exprtk::details::load_operations_map ( std::multimap< std::string, details::base_operation_t, details::ilesscompare > & m )

inline

Definition at line 19714 of file exprtk.hpp.

      {
         #define register_op(Symbol, Type, Args)                                             \
         m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \
 
         register_op("abs"       , e_abs     , 1)
         register_op("acos"      , e_acos    , 1)
         register_op("acosh"     , e_acosh   , 1)
         register_op("asin"      , e_asin    , 1)
         register_op("asinh"     , e_asinh   , 1)
         register_op("atan"      , e_atan    , 1)
         register_op("atanh"     , e_atanh   , 1)
         register_op("ceil"      , e_ceil    , 1)
         register_op("cos"       , e_cos     , 1)
         register_op("cosh"      , e_cosh    , 1)
         register_op("exp"       , e_exp     , 1)
         register_op("expm1"     , e_expm1   , 1)
         register_op("floor"     , e_floor   , 1)
         register_op("log"       , e_log     , 1)
         register_op("log10"     , e_log10   , 1)
         register_op("log2"      , e_log2    , 1)
         register_op("log1p"     , e_log1p   , 1)
         register_op("round"     , e_round   , 1)
         register_op("sin"       , e_sin     , 1)
         register_op("sinc"      , e_sinc    , 1)
         register_op("sinh"      , e_sinh    , 1)
         register_op("sec"       , e_sec     , 1)
         register_op("csc"       , e_csc     , 1)
         register_op("sqrt"      , e_sqrt    , 1)
         register_op("tan"       , e_tan     , 1)
         register_op("tanh"      , e_tanh    , 1)
         register_op("cot"       , e_cot     , 1)
         register_op("rad2deg"   , e_r2d     , 1)
         register_op("deg2rad"   , e_d2r     , 1)
         register_op("deg2grad"  , e_d2g     , 1)
         register_op("grad2deg"  , e_g2d     , 1)
         register_op("sgn"       , e_sgn     , 1)
         register_op("not"       , e_notl    , 1)
         register_op("erf"       , e_erf     , 1)
         register_op("erfc"      , e_erfc    , 1)
         register_op("ncdf"      , e_ncdf    , 1)
         register_op("frac"      , e_frac    , 1)
         register_op("trunc"     , e_trunc   , 1)
         register_op("atan2"     , e_atan2   , 2)
         register_op("mod"       , e_mod     , 2)
         register_op("logn"      , e_logn    , 2)
         register_op("pow"       , e_pow     , 2)
         register_op("root"      , e_root    , 2)
         register_op("roundn"    , e_roundn  , 2)
         register_op("equal"     , e_equal   , 2)
         register_op("not_equal" , e_nequal  , 2)
         register_op("hypot"     , e_hypot   , 2)
         register_op("shr"       , e_shr     , 2)
         register_op("shl"       , e_shl     , 2)
         register_op("clamp"     , e_clamp   , 3)
         register_op("iclamp"    , e_iclamp  , 3)
         register_op("inrange"   , e_inrange , 3)
         #undef register_op
      }

References e_abs, e_acos, e_acosh, e_asin, e_asinh, e_atan, e_atan2, e_atanh, e_ceil, e_clamp, e_cos, e_cosh, e_cot, e_csc, e_d2g, e_d2r, e_equal, e_erf, e_erfc, e_exp, e_expm1, e_floor, e_frac, e_g2d, e_hypot, e_iclamp, e_inrange, e_log, e_log10, e_log1p, e_log2, e_logn, e_mod, e_ncdf, e_nequal, e_notl, e_pow, e_r2d, e_root, e_round, e_roundn, e_sec, e_sgn, e_shl, e_shr, e_sin, e_sinc, e_sinh, e_sqrt, e_tan, e_tanh, e_trunc, and register_op.

make_memory_context() [1/2]

template<typename T>

memory_context_t< T > exprtk::details::make_memory_context ( vector_holder< T > & vec_holder, vec_data_store< T > & vds )

inline

Definition at line 13698 of file exprtk.hpp.

      {
         memory_context_t<T> result_ctxt;
 
         result_ctxt.temp_  = (vec_holder.rebaseable()) ?
                              new vector_holder<T>(vec_holder,vds) :
                              new vector_holder<T>(vds) ;
 
         result_ctxt.temp_vec_node_ = new vector_node<T>(vds,result_ctxt.temp_);
 
         return result_ctxt;
      }

References exprtk::details::vector_holder< Type >::rebaseable(), exprtk::details::memory_context_t< T >::temp_, and exprtk::details::memory_context_t< T >::temp_vec_node_.

Referenced by exprtk::details::conditional_vector_node< T >::conditional_vector_node(), exprtk::details::unary_vector_node< T, Operation >::unary_vector_node(), exprtk::details::vec_binop_valvec_node< T, Operation >::vec_binop_valvec_node(), exprtk::details::vec_binop_vecval_node< T, Operation >::vec_binop_vecval_node(), and exprtk::details::vec_binop_vecvec_node< T, Operation >::vec_binop_vecvec_node().

Here is the call graph for this function:

Here is the caller graph for this function:

make_memory_context() [2/2]

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 )

inline

Definition at line 13713 of file exprtk.hpp.

      {
         memory_context_t<T> result_ctxt;
 
         if (!vec_holder0.rebaseable() && !vec_holder1.rebaseable())
            result_ctxt.temp_ = new vector_holder<T>(vds);
         else if (vec_holder0.rebaseable() && !vec_holder1.rebaseable())
            result_ctxt.temp_ = new vector_holder<T>(vec_holder0,vds);
         else if (!vec_holder0.rebaseable() && vec_holder1.rebaseable())
            result_ctxt.temp_ = new vector_holder<T>(vec_holder1,vds);
         else
         {
            result_ctxt.temp_ = (vec_holder0.base_size() >= vec_holder1.base_size()) ?
                                new vector_holder<T>(vec_holder0, vds) :
                                new vector_holder<T>(vec_holder1, vds) ;
         }
 
         result_ctxt.temp_vec_node_ = new vector_node<T>(vds,result_ctxt.temp_);
 
         return result_ctxt;
      }

References exprtk::details::vector_holder< Type >::base_size(), exprtk::details::vector_holder< Type >::rebaseable(), exprtk::details::memory_context_t< T >::temp_, and exprtk::details::memory_context_t< T >::temp_vec_node_.

Here is the call graph for this function:

match_impl()

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 )

inline

Definition at line 605 of file exprtk.hpp.

      {
         typedef typename std::iterator_traits<Iterator>::value_type type;
 
         const Iterator null_itr(0);
 
         Iterator p_itr  = pattern_begin;
         Iterator d_itr  = data_begin;
         Iterator np_itr = null_itr;
         Iterator nd_itr = null_itr;
 
         for ( ; ; )
         {
            if (p_itr != pattern_end)
            {
               const type c = *(p_itr);
 
               if ((data_end != d_itr) && (Compare::cmp(c,*(d_itr)) || (exactly_one == c)))
               {
                  ++d_itr;
                  ++p_itr;
                  continue;
               }
               else if (zero_or_more == c)
               {
                  while ((pattern_end != p_itr) && (zero_or_more == *(p_itr)))
                  {
                     ++p_itr;
                  }
 
                  const type d = *(p_itr);
 
                  while ((data_end != d_itr) && !(Compare::cmp(d,*(d_itr)) || (exactly_one == d)))
                  {
                     ++d_itr;
                  }
 
                  // set backtrack iterators
                  np_itr = p_itr - 1;
                  nd_itr = d_itr + 1;
 
                  continue;
               }
            }
            else if (data_end == d_itr)
               break;
 
            if ((data_end == d_itr) || (null_itr == nd_itr))
                return false;
 
            p_itr = np_itr;
            d_itr = nd_itr;
         }
 
         return true;
      }

Referenced by wc_imatch(), and wc_match().

Here is the caller graph for this function:

parse_hex()

template<typename Iterator>

bool exprtk::details::parse_hex ( Iterator & itr, Iterator end, char_t & result )

inline

Definition at line 328 of file exprtk.hpp.

      {
         if (
              (end ==  (itr    ))               ||
              (end ==  (itr + 1))               ||
              (end ==  (itr + 2))               ||
              (end ==  (itr + 3))               ||
              ('0' != *(itr    ))               ||
              ('X' != std::toupper(*(itr + 1))) ||
              (!is_hex_digit(*(itr + 2)))       ||
              (!is_hex_digit(*(itr + 3)))
            )
         {
            return false;
         }
 
         result = static_cast<char_t>(
                     hex_to_bin(static_cast<uchar_t>(*(itr + 2))) << 4 |
                     hex_to_bin(static_cast<uchar_t>(*(itr + 3)))) ;
 
         return true;
      }

References hex_to_bin(), is_hex_digit(), and nodetype_T0oT1< T, T0, T1 >::result.

Referenced by cleanup_escapes().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_inf()

template<typename Iterator, typename T>

bool exprtk::details::parse_inf ( Iterator & itr, const Iterator end, T & t, const bool negative )

inlinestatic

Definition at line 1932 of file exprtk.hpp.

      {
         static const char_t inf_uc[] = "INFINITY";
         static const char_t inf_lc[] = "infinity";
         static const std::size_t inf_length = 8;
 
         const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));
 
         if ((3 != length) && (inf_length != length))
            return false;
 
         char_cptr inf_itr = ('i' == (*itr)) ? inf_lc : inf_uc;
 
         while (end != itr)
         {
            if (*inf_itr == static_cast<char_t>(*itr))
            {
               ++itr;
               ++inf_itr;
               continue;
            }
            else
               return false;
         }
 
         if (negative)
            t = -std::numeric_limits<T>::infinity();
         else
            t =  std::numeric_limits<T>::infinity();
 
         return true;
      }

Referenced by string_to_real().

Here is the caller graph for this function:

parse_nan()

template<typename Iterator, typename T>

bool exprtk::details::parse_nan ( Iterator & itr, const Iterator end, T & t )

inlinestatic

Definition at line 1899 of file exprtk.hpp.

      {
         typedef typename std::iterator_traits<Iterator>::value_type type;
 
         static const std::size_t nan_length = 3;
 
         if (std::distance(itr,end) != static_cast<int>(nan_length))
            return false;
 
         if (static_cast<type>('n') == (*itr))
         {
            if (
                 (static_cast<type>('a') != *(itr + 1)) ||
                 (static_cast<type>('n') != *(itr + 2))
               )
            {
               return false;
            }
         }
         else if (
                   (static_cast<type>('A') != *(itr + 1)) ||
                   (static_cast<type>('N') != *(itr + 2))
                 )
         {
            return false;
         }
 
         t = std::numeric_limits<T>::quiet_NaN();
 
         return true;
      }

Referenced by string_to_real().

Here is the caller graph for this function:

sequence_match()

bool exprtk::details::sequence_match ( const std::string & pattern, const std::string & str, std::size_t & diff_index, char_t & diff_value )

inline

Definition at line 693 of file exprtk.hpp.

      {
         if (str.empty())
         {
            return ("Z" == pattern);
         }
         else if ('*' == pattern[0])
            return false;
 
         typedef std::string::const_iterator itr_t;
 
         itr_t p_itr = pattern.begin();
         itr_t s_itr = str    .begin();
 
         const itr_t p_end = pattern.end();
         const itr_t s_end = str    .end();
 
         while ((s_end != s_itr) && (p_end != p_itr))
         {
            if ('*' == (*p_itr))
            {
               const char_t target = static_cast<char_t>(std::toupper(*(p_itr - 1)));
 
               if ('*' == target)
               {
                  diff_index = static_cast<std::size_t>(std::distance(str.begin(),s_itr));
                  diff_value = static_cast<char_t>(std::toupper(*p_itr));
 
                  return false;
               }
               else
                  ++p_itr;
 
               while (s_itr != s_end)
               {
                  if (target != std::toupper(*s_itr))
                     break;
                  else
                     ++s_itr;
               }
 
               continue;
            }
            else if (
                      ('?' != *p_itr) &&
                      std::toupper(*p_itr) != std::toupper(*s_itr)
                    )
            {
               diff_index = static_cast<std::size_t>(std::distance(str.begin(),s_itr));
               diff_value = static_cast<char_t>(std::toupper(*p_itr));
 
               return false;
            }
 
            ++p_itr;
            ++s_itr;
         }
 
         return (
                  (s_end == s_itr) &&
                  (
                    (p_end ==  p_itr) ||
                    ('*'   == *p_itr)
                  )
                );
      }

Referenced by exprtk::parser< T >::type_checker::verify().

Here is the caller graph for this function:

set_zero_value() [1/2]

template<typename T>

void exprtk::details::set_zero_value ( std::vector< T > & v )

inline

Definition at line 799 of file exprtk.hpp.

      {
         set_zero_value(v.data(),v.size());
      }

References set_zero_value().

Here is the call graph for this function:

set_zero_value() [2/2]

template<typename T>

void exprtk::details::set_zero_value ( T * data, const std::size_t size )

inline

Definition at line 793 of file exprtk.hpp.

      {
         set_zero_value_impl<T>::process(data,size);
      }

References exprtk::details::set_zero_value_impl< T >::process().

Referenced by exprtk::parser< Type >::parse_define_vector_statement(), set_zero_value(), exprtk::details::vector_init_zero_value_node< T >::value(), and exprtk::details::vector_initialisation_node< T >::value().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_real() [1/5]

template<typename T>

bool exprtk::details::string_to_real ( const std::string & s, T & t )

inline

Definition at line 2132 of file exprtk.hpp.

      {
         const typename numeric::details::number_type<T>::type num_type;
 
         char_cptr begin = s.data();
         char_cptr end   = s.data() + s.size();
 
         return string_to_real(begin, end, t, num_type);
      }

References string_to_real().

Here is the call graph for this function:

string_to_real() [2/5]

template<typename Iterator>

bool exprtk::details::string_to_real ( Iterator & itr_external, const Iterator end, cmplx::complex_t & t, details::numeric::details::complex_type_tag  )

inline

Definition at line 363 of file exprtk_complex_adaptor.hpp.

      {
         typename numeric::details::number_type<double>::type num_type;
         double real_component;
         const bool result = string_to_real<Iterator,double>(itr_external,end,real_component,num_type);
         t.c_.real(real_component);
         return result;
      }

References cmplx::complex_t::c_, nodetype_T0oT1< T, T0, T1 >::result, and string_to_real().

Here is the call graph for this function:

string_to_real() [3/5]

template<typename Iterator>

bool exprtk::details::string_to_real ( Iterator & itr_external, const Iterator end, mpfr::mpreal & t, numeric::details::mpfrreal_type_tag  )

inline

Definition at line 376 of file exprtk_mpfr_adaptor.hpp.

      {
         t = mpfr::mpreal(std::string(itr_external,end));
         return true;
      }

string_to_real() [4/5]

template<typename Iterator>

bool exprtk::details::string_to_real ( Iterator & itr_external, const Iterator end, real::type & t, details::numeric::details::my_real_type_tag  )

inline

Definition at line 351 of file exprtk_real_adaptor.hpp.

      {
         typename numeric::details::number_type<double>::type num_type;
         return string_to_real<Iterator,double>(itr_external,end,t.d_,num_type);
      }

References real::type::d_, and string_to_real().

Here is the call graph for this function:

string_to_real() [5/5]

template<typename Iterator, typename T>

bool exprtk::details::string_to_real ( Iterator & itr_external, const Iterator end, T & t, numeric::details::real_type_tag  )

inline

Definition at line 1973 of file exprtk.hpp.

      {
         if (end == itr_external) return false;
 
         Iterator itr = itr_external;
 
         T d = T(0);
 
         const bool negative = ('-' == (*itr));
 
         if (negative || '+' == (*itr))
         {
            if (end == ++itr)
               return false;
         }
 
         bool instate = false;
 
         static const char_t zero = static_cast<uchar_t>('0');
 
         #define parse_digit_1(d)          \
         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
         if (end == ++itr) break;          \
 
         #define parse_digit_2(d)          \
         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
            ++itr;                         \
 
         if ('.' != (*itr))
         {
            const Iterator curr = itr;
 
            while ((end != itr) && (zero == (*itr))) ++itr;
 
            while (end != itr)
            {
               unsigned int digit;
               parse_digit_1(d)
               parse_digit_1(d)
               parse_digit_2(d)
            }
 
            if (curr != itr) instate = true;
         }
 
         int exponent = 0;
 
         if (end != itr)
         {
            if ('.' == (*itr))
            {
               const Iterator curr = ++itr;
               T tmp_d = T(0);
 
               while (end != itr)
               {
                  unsigned int digit;
                  parse_digit_1(tmp_d)
                  parse_digit_1(tmp_d)
                  parse_digit_2(tmp_d)
               }
 
               if (curr != itr)
               {
                  instate = true;
 
                  const int frac_exponent = static_cast<int>(-std::distance(curr, itr));
 
                  if (!valid_exponent<T>(frac_exponent, numeric::details::real_type_tag()))
                     return false;
 
                  d += compute_pow10(tmp_d, frac_exponent);
               }
 
               #undef parse_digit_1
               #undef parse_digit_2
            }
 
            if (end != itr)
            {
               typename std::iterator_traits<Iterator>::value_type c = (*itr);
 
               if (('e' == c) || ('E' == c))
               {
                  int exp = 0;
 
                  if (!details::string_to_type_converter_impl_ref(++itr, end, exp))
                  {
                     if (end == itr)
                        return false;
                     else
                        c = (*itr);
                  }
 
                  exponent += exp;
               }
 
               if (end != itr)
               {
                  if (('f' == c) || ('F' == c) || ('l' == c) || ('L' == c))
                     ++itr;
                  else if ('#' == c)
                  {
                     if (end == ++itr)
                        return false;
 
                     if (('I' <= (*itr)) && ((*itr) <= 'n'))
                     {
                        if (('i' == (*itr)) || ('I' == (*itr)))
                        {
                           return parse_inf(itr, end, t, negative);
                        }
                        else if (('n' == (*itr)) || ('N' == (*itr)))
                        {
                           return parse_nan(itr, end, t);
                        }
                        else
                           return false;
                     }
                     else
                        return false;
                  }
                  else if (('I' <= (*itr)) && ((*itr) <= 'n'))
                  {
                     if (('i' == (*itr)) || ('I' == (*itr)))
                     {
                        return parse_inf(itr, end, t, negative);
                     }
                     else if (('n' == (*itr)) || ('N' == (*itr)))
                     {
                        return parse_nan(itr, end, t);
                     }
                     else
                        return false;
                  }
                  else
                     return false;
               }
            }
         }
 
         if ((end != itr) || (!instate))
            return false;
         else if (!valid_exponent<T>(exponent, numeric::details::real_type_tag()))
            return false;
         else if (exponent)
            d = compute_pow10(d,exponent);
 
         t = static_cast<T>((negative) ? -d : d);
         return true;
      }

References compute_pow10(), parse_digit_1, parse_digit_2, parse_inf(), parse_nan(), string_to_type_converter_impl_ref(), and valid_exponent().

Referenced by exprtk::lexer::helper::numeric_checker< T >::operator()(), exprtk::parser< Type >::parse_branch(), string_to_real(), string_to_real(), and string_to_real().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_type_converter_impl_ref()

template<typename Iterator, typename T>

bool exprtk::details::string_to_type_converter_impl_ref ( Iterator & itr, const Iterator end, T & result )

inline

Definition at line 1822 of file exprtk.hpp.

      {
         if (itr == end)
            return false;
 
         const bool negative = ('-' == (*itr));
 
         if (negative || ('+' == (*itr)))
         {
            if (end == ++itr)
               return false;
         }
 
         static const uchar_t zero = static_cast<uchar_t>('0');
 
         while ((end != itr) && (zero == (*itr))) ++itr;
 
         bool return_result = true;
         unsigned int digit = 0;
         const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));
 
         if (length <= 4)
         {
            switch (length)
            {
               #ifdef exprtk_use_lut
 
               #define exprtk_process_digit                          \
               if ((digit = details::digit_table[(int)*itr++]) < 10) \
                  result = result * 10 + (digit);                    \
               else                                                  \
               {                                                     \
                  return_result = false;                             \
                  break;                                             \
               }                                                     \
               exprtk_fallthrough                                    \
 
               #else
 
               #define exprtk_process_digit        \
               if ((digit = (*itr++ - zero)) < 10) \
                  result = result * T(10) + digit; \
               else                                \
               {                                   \
                  return_result = false;           \
                  break;                           \
               }                                   \
               exprtk_fallthrough                  \
 
               #endif
 
               case 4 : exprtk_process_digit
               case 3 : exprtk_process_digit
               case 2 : exprtk_process_digit
               case 1 : if ((digit = (*itr - zero)) >= 10)
                        {
                           digit = 0;
                           return_result = false;
                        }
 
               #undef exprtk_process_digit
            }
         }
         else
            return_result = false;
 
         if (length && return_result)
         {
            result = result * 10 + static_cast<T>(digit);
            ++itr;
         }
 
         result = negative ? -result : result;
         return return_result;
      }

References exprtk_process_digit, and nodetype_T0oT1< T, T0, T1 >::result.

Referenced by string_to_real().

Here is the caller graph for this function:

to_str() [1/3]

std::string exprtk::details::to_str ( const operator_type opr )

inline

Definition at line 5216 of file exprtk.hpp.

      {
         switch (opr)
         {
            case e_add    : return  "+"  ;
            case e_sub    : return  "-"  ;
            case e_mul    : return  "*"  ;
            case e_div    : return  "/"  ;
            case e_mod    : return  "%"  ;
            case e_pow    : return  "^"  ;
            case e_assign : return ":="  ;
            case e_addass : return "+="  ;
            case e_subass : return "-="  ;
            case e_mulass : return "*="  ;
            case e_divass : return "/="  ;
            case e_modass : return "%="  ;
            case e_lt     : return  "<"  ;
            case e_lte    : return "<="  ;
            case e_eq     : return "=="  ;
            case e_equal  : return  "="  ;
            case e_ne     : return "!="  ;
            case e_nequal : return "<>"  ;
            case e_gte    : return ">="  ;
            case e_gt     : return  ">"  ;
            case e_and    : return "and" ;
            case e_or     : return "or"  ;
            case e_xor    : return "xor" ;
            case e_nand   : return "nand";
            case e_nor    : return "nor" ;
            case e_xnor   : return "xnor";
            default       : return "N/A" ;
         }
      }

References e_add, e_addass, e_and, e_assign, e_div, e_divass, e_eq, e_equal, e_gt, e_gte, e_lt, e_lte, e_mod, e_modass, e_mul, e_mulass, e_nand, e_ne, e_nequal, e_nor, e_or, e_pow, e_sub, e_subass, e_xnor, and e_xor.

to_str() [2/3]

std::string exprtk::details::to_str ( int i )

inline

Definition at line 302 of file exprtk.hpp.

      {
         return to_str_impl(i);
      }

References to_str_impl().

Referenced by depth_to_str< T >::operator()(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< Type >::parse_const_string(), exprtk::parser< Type >::parse_define_constvar_statement(), exprtk::parser< Type >::parse_define_var_statement(), exprtk::parser< Type >::parse_define_vector_statement(), exprtk::parser< Type >::parse_expression(), exprtk::parser< Type >::parse_function_call(), exprtk::parser< T >::type_checker::parse_function_prototypes(), exprtk::parser< Type >::parse_uninitialised_var_statement(), exprtk::parser< Type >::parse_vararg_function_call(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::parser< Type >::synthesize_vector_element(), exprtk::parser< Type >::valid_settings(), and exprtk::parser< T >::expression_generator< Type >::vector_element().

Here is the call graph for this function:

Here is the caller graph for this function:

to_str() [3/3]

std::string exprtk::details::to_str ( std::size_t i )

inline

Definition at line 307 of file exprtk.hpp.

      {
         return to_str_impl(static_cast<long long int>(i));
      }

References to_str_impl().

Here is the call graph for this function:

to_str_impl()

template<typename SignedType>

std::string exprtk::details::to_str_impl ( SignedType i )

inline

Definition at line 278 of file exprtk.hpp.

      {
         if (0 == i)
            return std::string("0");
 
         std::string result;
 
         const int sign = (i < 0) ? -1 : 1;
 
         for ( ; i; i /= 10)
         {
            result += '0' + static_cast<char_t>(sign * (i % 10));
         }
 
         if (sign < 0)
         {
            result += '-';
         }
 
         std::reverse(result.begin(), result.end());
 
         return result;
      }

References nodetype_T0oT1< T, T0, T1 >::result.

Referenced by to_str(), and to_str().

Here is the caller graph for this function:

valid_exponent()

template<typename T>

bool exprtk::details::valid_exponent ( const int exponent, numeric::details::real_type_tag  )

inline

Definition at line 1966 of file exprtk.hpp.

      {
         using namespace details::numeric;
         return (numeric_info<T>::min_exp <= exponent) && (exponent <= numeric_info<T>::max_exp);
      }

Referenced by string_to_real().

Here is the caller graph for this function:

value() [1/4]

template<typename T>

T exprtk::details::value ( const T & t )

inline

Definition at line 16046 of file exprtk.hpp.

      {
         return t;
      }

value() [2/4]

template<typename T>

T exprtk::details::value ( const T * t )

inline

Definition at line 16040 of file exprtk.hpp.

      {
         return (*t);
      }

value() [3/4]

template<typename T>

T exprtk::details::value ( details::expression_node< T > * n )

inline

Definition at line 16028 of file exprtk.hpp.

      {
         return n->value();
      }

References exprtk::details::expression_node< T >::value().

Referenced by exprtk::details::vararg_add_op< T >::process(), exprtk::details::vararg_mand_op< T >::process(), exprtk::details::vararg_max_op< T >::process(), exprtk::details::vararg_min_op< T >::process(), exprtk::details::vararg_mor_op< T >::process(), exprtk::details::vararg_mul_op< T >::process(), exprtk::details::vararg_multi_op< T >::process(), exprtk::details::vararg_add_op< T >::process_1(), exprtk::details::vararg_avg_op< T >::process_1(), exprtk::details::vararg_mand_op< T >::process_1(), exprtk::details::vararg_max_op< T >::process_1(), exprtk::details::vararg_min_op< T >::process_1(), exprtk::details::vararg_mor_op< T >::process_1(), exprtk::details::vararg_mul_op< T >::process_1(), exprtk::details::vararg_multi_op< T >::process_1(), exprtk::details::vararg_add_op< T >::process_2(), exprtk::details::vararg_avg_op< T >::process_2(), exprtk::details::vararg_mand_op< T >::process_2(), exprtk::details::vararg_max_op< T >::process_2(), exprtk::details::vararg_min_op< T >::process_2(), exprtk::details::vararg_mor_op< T >::process_2(), exprtk::details::vararg_mul_op< T >::process_2(), exprtk::details::vararg_multi_op< T >::process_2(), exprtk::details::vararg_add_op< T >::process_3(), exprtk::details::vararg_avg_op< T >::process_3(), exprtk::details::vararg_mand_op< T >::process_3(), exprtk::details::vararg_max_op< T >::process_3(), exprtk::details::vararg_min_op< T >::process_3(), exprtk::details::vararg_mor_op< T >::process_3(), exprtk::details::vararg_mul_op< T >::process_3(), exprtk::details::vararg_multi_op< T >::process_3(), exprtk::details::vararg_add_op< T >::process_4(), exprtk::details::vararg_avg_op< T >::process_4(), exprtk::details::vararg_mand_op< T >::process_4(), exprtk::details::vararg_max_op< T >::process_4(), exprtk::details::vararg_min_op< T >::process_4(), exprtk::details::vararg_mor_op< T >::process_4(), exprtk::details::vararg_mul_op< T >::process_4(), exprtk::details::vararg_multi_op< T >::process_4(), exprtk::details::vararg_add_op< T >::process_5(), exprtk::details::vararg_avg_op< T >::process_5(), exprtk::details::vararg_mand_op< T >::process_5(), exprtk::details::vararg_max_op< T >::process_5(), exprtk::details::vararg_min_op< T >::process_5(), exprtk::details::vararg_mor_op< T >::process_5(), exprtk::details::vararg_mul_op< T >::process_5(), exprtk::details::vararg_multi_op< T >::process_5(), exprtk::details::vararg_multi_op< T >::process_6(), exprtk::details::vararg_multi_op< T >::process_7(), and exprtk::details::vararg_multi_op< T >::process_8().

Here is the call graph for this function:

Here is the caller graph for this function:

value() [4/4]

template<typename T>

T exprtk::details::value ( std::pair< details::expression_node< T > *, bool > n )

inline

Definition at line 16034 of file exprtk.hpp.

      {
         return n.first->value();
      }

wc_imatch()

bool exprtk::details::wc_imatch ( const std::string & wild_card, const std::string & str )

inline

Definition at line 680 of file exprtk.hpp.

      {
         return match_impl<char_cptr,cis_match>
                (
                   wild_card.data(),
                   wild_card.data() + wild_card.size(),
                   str.data(),
                   str.data() + str.size(),
                   '*', '?'
                );
      }

References match_impl().

Referenced by exprtk::details::ilike_op< T >::process().

Here is the call graph for this function:

Here is the caller graph for this function:

wc_match()

bool exprtk::details::wc_match ( const std::string & wild_card, const std::string & str )

inline

Definition at line 667 of file exprtk.hpp.

      {
         return match_impl<char_cptr,cs_match>
                (
                   wild_card.data(),
                   wild_card.data() + wild_card.size(),
                   str.data(),
                   str.data() + str.size(),
                   '*', '?'
                );
      }

References match_impl().

Referenced by exprtk::details::like_op< T >::process().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

arithmetic_ops_list

const std::string exprtk::details::arithmetic_ops_list[]

static

Initial value:

                                             =
{
   "+", "-", "*", "/", "%", "^"
}

Definition at line 499 of file exprtk.hpp.

                                                         {
         "+", "-", "*", "/", "%", "^"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_arithmetic_ops(), exprtk::parser< T >::settings_store::disable_arithmetic_operation(), and exprtk::parser< T >::settings_store::enable_arithmetic_operation().

arithmetic_ops_list_size

const std::size_t exprtk::details::arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string)

static

Definition at line 504 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_arithmetic_ops(), exprtk::parser< T >::settings_store::disable_arithmetic_operation(), and exprtk::parser< T >::settings_store::enable_arithmetic_operation().

assignment_ops_list

const std::string exprtk::details::assignment_ops_list[]

static

Initial value:

                                             =
{
   ":=", "+=", "-=",
   "*=", "/=", "%="
}

Definition at line 506 of file exprtk.hpp.

                                                         {
         ":=", "+=", "-=",
         "*=", "/=", "%="
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_assignment_ops(), exprtk::parser< T >::settings_store::disable_assignment_operation(), and exprtk::parser< T >::settings_store::enable_assignment_operation().

assignment_ops_list_size

const std::size_t exprtk::details::assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string)

static

Definition at line 512 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_assignment_ops(), exprtk::parser< T >::settings_store::disable_assignment_operation(), and exprtk::parser< T >::settings_store::enable_assignment_operation().

base_function_list

const std::string exprtk::details::base_function_list[]

static

Initial value:

                                            =
{
   "abs", "acos",  "acosh", "asin",  "asinh", "atan",  "atanh",
   "atan2",  "avg",  "ceil",  "clamp",  "cos",  "cosh",  "cot",
   "csc",  "equal",  "erf",  "erfc",  "exp",  "expm1", "floor",
   "frac", "hypot", "iclamp",  "like", "log", "log10",  "log2",
   "logn", "log1p", "mand", "max", "min", "mod", "mor",  "mul",
   "ncdf",  "pow",  "root",  "round",  "roundn",  "sec", "sgn",
   "sin", "sinc", "sinh", "sqrt", "sum", "swap", "tan", "tanh",
   "trunc",  "not_equal",  "inrange",  "deg2grad",   "deg2rad",
   "rad2deg", "grad2deg"
}

Definition at line 470 of file exprtk.hpp.

                                                        {
         "abs", "acos",  "acosh", "asin",  "asinh", "atan",  "atanh",
         "atan2",  "avg",  "ceil",  "clamp",  "cos",  "cosh",  "cot",
         "csc",  "equal",  "erf",  "erfc",  "exp",  "expm1", "floor",
         "frac", "hypot", "iclamp",  "like", "log", "log10",  "log2",
         "logn", "log1p", "mand", "max", "min", "mod", "mor",  "mul",
         "ncdf",  "pow",  "root",  "round",  "roundn",  "sec", "sgn",
         "sin", "sinc", "sinh", "sqrt", "sum", "swap", "tan", "tanh",
         "trunc",  "not_equal",  "inrange",  "deg2grad",   "deg2rad",
         "rad2deg", "grad2deg"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_base_functions(), exprtk::parser< T >::settings_store::disable_base_function(), exprtk::parser< T >::settings_store::enable_base_function(), and is_base_function().

base_function_list_size

const std::size_t exprtk::details::base_function_list_size = sizeof(base_function_list) / sizeof(std::string)

static

Definition at line 483 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_base_functions(), exprtk::parser< T >::settings_store::disable_base_function(), exprtk::parser< T >::settings_store::enable_base_function(), and is_base_function().

cntrl_struct_list

const std::string exprtk::details::cntrl_struct_list[]

static

Initial value:

                                           =
{
   "if", "switch", "for", "while", "repeat", "return"
}

Definition at line 492 of file exprtk.hpp.

                                                       {
         "if", "switch", "for", "while", "repeat", "return"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_control_structures(), exprtk::parser< T >::settings_store::disable_control_structure(), exprtk::parser< T >::settings_store::enable_control_structure(), and is_control_struct().

cntrl_struct_list_size

const std::size_t exprtk::details::cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string)

static

Definition at line 497 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_control_structures(), exprtk::parser< T >::settings_store::disable_control_structure(), exprtk::parser< T >::settings_store::enable_control_structure(), and is_control_struct().

inequality_ops_list

const std::string exprtk::details::inequality_ops_list[]

static

Initial value:

                                             =
{
   "<",  "<=", "==",
   "=",  "!=", "<>",
   ">=",  ">"
}

Definition at line 514 of file exprtk.hpp.

                                                         {
         "<",  "<=", "==",
         "=",  "!=", "<>",
         ">=",  ">"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_inequality_ops(), exprtk::parser< T >::settings_store::disable_inequality_operation(), and exprtk::parser< T >::settings_store::enable_inequality_operation().

inequality_ops_list_size

const std::size_t exprtk::details::inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string)

static

Definition at line 521 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_inequality_ops(), exprtk::parser< T >::settings_store::disable_inequality_operation(), and exprtk::parser< T >::settings_store::enable_inequality_operation().

logic_ops_list

const std::string exprtk::details::logic_ops_list[]

static

Initial value:

                                        =
{
   "and", "nand", "nor", "not", "or",  "xnor", "xor", "&", "|"
}

Definition at line 485 of file exprtk.hpp.

                                                    {
         "and", "nand", "nor", "not", "or",  "xnor", "xor", "&", "|"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_logic_ops(), exprtk::parser< T >::settings_store::disable_logic_operation(), exprtk::parser< T >::settings_store::enable_logic_operation(), and is_logic_opr().

logic_ops_list_size

const std::size_t exprtk::details::logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string)

static

Definition at line 490 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_logic_ops(), exprtk::parser< T >::settings_store::disable_logic_operation(), exprtk::parser< T >::settings_store::enable_logic_operation(), and is_logic_opr().

nodetype_T0oT1< T, constT0 &, constT1 & >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, constT0 &, constT1 & >::result = expression_node<T>:: e_vov

Definition at line 17446 of file exprtk.hpp.

nodetype_T0oT1< T, constT0 &, constT1 >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, constT0 &, constT1 >::result = expression_node<T>:: e_voc

Definition at line 17447 of file exprtk.hpp.

nodetype_T0oT1< T, constT0 &, T1 & >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, constT0 &, T1 & >::result = expression_node<T>:: e_none

Definition at line 17453 of file exprtk.hpp.

nodetype_T0oT1< T, constT0, constT1 & >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, constT0, constT1 & >::result = expression_node<T>:: e_cov

Definition at line 17448 of file exprtk.hpp.

nodetype_T0oT1< T, constT0, constT1 >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, constT0, constT1 >::result = expression_node<T>:: e_none

Definition at line 17450 of file exprtk.hpp.

nodetype_T0oT1< T, constT0, T1 & >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, constT0, T1 & >::result = expression_node<T>:: e_none

Definition at line 17452 of file exprtk.hpp.

nodetype_T0oT1< T, T0 &, constT1 & >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, T0 &, constT1 & >::result = expression_node<T>:: e_none

Definition at line 17454 of file exprtk.hpp.

nodetype_T0oT1< T, T0 &, constT1 >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, T0 &, constT1 >::result = expression_node<T>:: e_none

Definition at line 17451 of file exprtk.hpp.

nodetype_T0oT1< T, T0 &, T1 & >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, T0 &, T1 & >::result = expression_node<T>:: e_none

Definition at line 17449 of file exprtk.hpp.

nodetype_T0oT1< T, T0, T1 >::result

template<typename T, typename T0, typename T1>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1< T, T0, T1 >::result = expression_node<T>::e_none

Definition at line 17438 of file exprtk.hpp.

Referenced by exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate(), exprtk::details::node_allocator::allocate_c(), exprtk::details::node_allocator::allocate_cr(), exprtk::details::node_allocator::allocate_rc(), exprtk::details::node_allocator::allocate_rr(), exprtk::details::node_allocator::allocate_rrr(), exprtk::details::node_allocator::allocate_rrrr(), exprtk::details::node_allocator::allocate_rrrrr(), exprtk::details::node_allocator::allocate_tt(), exprtk::details::node_allocator::allocate_ttt(), exprtk::details::node_allocator::allocate_tttt(), exprtk::details::node_allocator::allocate_type(), exprtk::details::node_allocator::allocate_type(), exprtk::details::node_allocator::allocate_type(), exprtk::details::node_allocator::allocate_type(), exprtk::details::node_allocator::allocate_type(), exprtk::details::numeric::details::erf_impl(), exprtk::details::numeric::details::erf_impl(), exprtk::details::T0oT1oT20T3process< T >::mode0::id(), exprtk::details::T0oT1oT20T3process< T >::mode1::id(), exprtk::details::T0oT1oT20T3process< T >::mode2::id(), exprtk::details::T0oT1oT20T3process< T >::mode3::id(), exprtk::details::T0oT1oT20T3process< T >::mode4::id(), exprtk::details::T0oT1oT2process< T >::mode0::id(), exprtk::details::T0oT1oT2process< T >::mode1::id(), parse_hex(), exprtk::details::vararg_add_op< T >::process(), exprtk::details::vararg_max_op< T >::process(), exprtk::details::vararg_min_op< T >::process(), exprtk::details::vararg_mul_op< T >::process(), exprtk::details::vec_add_op< T >::process(), exprtk::details::vec_max_op< T >::process(), exprtk::details::vec_min_op< T >::process(), exprtk::details::vec_mul_op< T >::process(), string_to_real(), string_to_type_converter_impl_ref(), to_str_impl(), exprtk::details::T0oT1< T, T0, T1 >::type(), exprtk::details::T0oT1oT2< T, T0, T1, T2, typename T0oT1oT2process< T >::mode0 >::type(), exprtk::details::T0oT1oT2_sf3< T, T0, T1, T2 >::type(), exprtk::details::T0oT1oT2_sf3ext< T, T0, T1, T2, SF3Operation >::type(), exprtk::details::T0oT1oT2oT3_sf4< T, T0, T1, T2, T3 >::type(), exprtk::details::T0oT1oT2oT3_sf4ext< T, T0, T1, T2, T3, SF4Operation >::type(), exprtk::details::assignment_node< T >::value(), exprtk::details::assignment_rebasevec_celem_node< T >::value(), exprtk::details::assignment_rebasevec_elem_node< T >::value(), exprtk::details::assignment_rebasevec_elem_rtc_node< T >::value(), exprtk::details::assignment_vec_elem_node< T >::value(), exprtk::details::assignment_vec_elem_rtc_node< T >::value(), exprtk::details::break_node< T >::value(), exprtk::details::conditional_vector_node< T >::value(), exprtk::details::for_loop_bc_node< T >::value(), exprtk::details::for_loop_bc_rtc_node< T >::value(), exprtk::details::for_loop_node< T >::value(), exprtk::details::for_loop_rtc_node< T >::value(), exprtk::details::multi_switch_node< T >::value(), exprtk::details::multimode_strfunction_node< T, StringFunction >::value(), exprtk::details::null_eq_node< T >::value(), exprtk::details::repeat_until_loop_bc_node< T >::value(), exprtk::details::repeat_until_loop_bc_rtc_node< T >::value(), exprtk::details::repeat_until_loop_node< T >::value(), exprtk::details::repeat_until_loop_rtc_node< T >::value(), exprtk::details::string_function_node< T, StringFunction >::value(), exprtk::details::while_loop_bc_node< T >::value(), exprtk::details::while_loop_bc_rtc_node< T >::value(), exprtk::details::while_loop_node< T >::value(), and exprtk::details::while_loop_rtc_node< T >::value().

nodetype_T0oT1oT2< T, constT0 &, constT1 &, constT2 & >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0 &, constT1 &, constT2 & >::result = expression_node<T>:: e_vovov

Definition at line 17468 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0 &, constT1 &, constT2 >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0 &, constT1 &, constT2 >::result = expression_node<T>:: e_vovoc

Definition at line 17469 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0 &, constT1, constT2 & >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0 &, constT1, constT2 & >::result = expression_node<T>:: e_vocov

Definition at line 17470 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0 &, constT1, constT2 >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0 &, constT1, constT2 >::result = expression_node<T>:: e_none

Definition at line 17475 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0, constT1 &, constT2 & >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0, constT1 &, constT2 & >::result = expression_node<T>:: e_covov

Definition at line 17471 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0, constT1 &, constT2 >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0, constT1 &, constT2 >::result = expression_node<T>:: e_covoc

Definition at line 17472 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0, constT1, constT2 & >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0, constT1, constT2 & >::result = expression_node<T>:: e_none

Definition at line 17474 of file exprtk.hpp.

nodetype_T0oT1oT2< T, constT0, constT1, constT2 >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, constT0, constT1, constT2 >::result = expression_node<T>:: e_none

Definition at line 17473 of file exprtk.hpp.

nodetype_T0oT1oT2< T, T0 &, T1 &, T2 & >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, T0 &, T1 &, T2 & >::result = expression_node<T>:: e_none

Definition at line 17476 of file exprtk.hpp.

nodetype_T0oT1oT2< T, T0, T1, T2 >::result

template<typename T, typename T0, typename T1, typename T2>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2< T, T0, T1, T2 >::result = expression_node<T>::e_none

Definition at line 17460 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2 &, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2 &, constT3 & >::result = expression_node<T>:: e_vovovov

Definition at line 17490 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2 &, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2 &, constT3 >::result = expression_node<T>:: e_vovovoc

Definition at line 17491 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2, constT3 & >::result = expression_node<T>:: e_vovocov

Definition at line 17492 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1 &, constT2, constT3 >::result = expression_node<T>:: e_none

Definition at line 17505 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2 &, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2 &, constT3 & >::result = expression_node<T>:: e_vocovov

Definition at line 17493 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2 &, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2 &, constT3 >::result = expression_node<T>:: e_vocovoc

Definition at line 17496 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2, constT3 & >::result = expression_node<T>:: e_vococov

Definition at line 17498 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0 &, constT1, constT2, constT3 >::result = expression_node<T>:: e_none

Definition at line 17503 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2 &, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2 &, constT3 & >::result = expression_node<T>:: e_covovov

Definition at line 17494 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2 &, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2 &, constT3 >::result = expression_node<T>:: e_covovoc

Definition at line 17497 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2, constT3 & >::result = expression_node<T>:: e_covocov

Definition at line 17495 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1 &, constT2, constT3 >::result = expression_node<T>:: e_none

Definition at line 17502 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2 &, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2 &, constT3 & >::result = expression_node<T>:: e_none

Definition at line 17504 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2 &, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2 &, constT3 >::result = expression_node<T>:: e_none

Definition at line 17501 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2, constT3 & >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2, constT3 & >::result = expression_node<T>:: e_none

Definition at line 17500 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2, constT3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, constT0, constT1, constT2, constT3 >::result = expression_node<T>:: e_none

Definition at line 17499 of file exprtk.hpp.

nodetype_T0oT1oT2oT3< T, T0, T1, T2, T3 >::result

template<typename T, typename T0, typename T1, typename T2, typename T3>

const expression_node<T>::node_type exprtk::details::nodetype_T0oT1oT2oT3< T, T0, T1, T2, T3 >::result = expression_node<T>::e_none

Definition at line 17482 of file exprtk.hpp.

pow10

const double exprtk::details::pow10[]

static

Initial value:

                          =
{
   1.0,
   1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004,
   1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008,
   1.0E+009, 1.0E+010, 1.0E+011, 1.0E+012,
   1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016
}

Definition at line 804 of file exprtk.hpp.

                                        {
         1.0,
         1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004,
         1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008,
         1.0E+009, 1.0E+010, 1.0E+011, 1.0E+012,
         1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016
      };

Referenced by exprtk::details::numeric::details::roundn_impl(), exprtk::details::numeric::details::roundn_impl(), and exprtk::details::numeric::details::roundn_impl().

pow10_size

const std::size_t exprtk::details::pow10_size = sizeof(pow10) / sizeof(double)

static

Definition at line 813 of file exprtk.hpp.

Referenced by exprtk::details::numeric::details::roundn_impl(), exprtk::details::numeric::details::roundn_impl(), and exprtk::details::numeric::details::roundn_impl().

reserved_symbols

const std::string exprtk::details::reserved_symbols[]

static

Initial value:

                                          =
{
   "abs", "acos",  "acosh", "and",  "asin", "asinh",  "assert",
   "atan", "atanh",  "atan2", "avg",  "break", "case",  "ceil",
   "clamp", "continue", "const",  "cos", "cosh", "cot",  "csc",
   "default",  "deg2grad", "deg2rad",  "equal", "erf",  "erfc",
   "exp", "expm1", "false", "floor", "for", "frac", "grad2deg",
   "hypot", "iclamp", "if",  "else", "ilike", "in",  "inrange",
   "like",  "log",  "log10", "log2",  "logn",  "log1p", "mand",
   "max", "min",  "mod", "mor",  "mul", "ncdf",  "nand", "nor",
   "not",   "not_equal",   "null",   "or",   "pow",  "rad2deg",
   "repeat", "return", "root", "round", "roundn", "sec", "sgn",
   "shl", "shr", "sin", "sinc", "sinh", "sqrt", "sum",  "swap",
   "switch", "tan",  "tanh", "true",  "trunc", "until",  "var",
   "while", "xnor", "xor", "&", "|"
}

Definition at line 451 of file exprtk.hpp.

                                                      {
         "abs", "acos",  "acosh", "and",  "asin", "asinh",  "assert",
         "atan", "atanh",  "atan2", "avg",  "break", "case",  "ceil",
         "clamp", "continue", "const",  "cos", "cosh", "cot",  "csc",
         "default",  "deg2grad", "deg2rad",  "equal", "erf",  "erfc",
         "exp", "expm1", "false", "floor", "for", "frac", "grad2deg",
         "hypot", "iclamp", "if",  "else", "ilike", "in",  "inrange",
         "like",  "log",  "log10", "log2",  "logn",  "log1p", "mand",
         "max", "min",  "mod", "mor",  "mul", "ncdf",  "nand", "nor",
         "not",   "not_equal",   "null",   "or",   "pow",  "rad2deg",
         "repeat", "return", "root", "round", "roundn", "sec", "sgn",
         "shl", "shr", "sin", "sinc", "sinh", "sqrt", "sum",  "swap",
         "switch", "tan",  "tanh", "true",  "trunc", "until",  "var",
         "while", "xnor", "xor", "&", "|"
      };

Referenced by exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), is_reserved_symbol(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

reserved_symbols_size

const std::size_t exprtk::details::reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string)

static

Definition at line 468 of file exprtk.hpp.

Referenced by exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), is_reserved_symbol(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

reserved_words

const std::string exprtk::details::reserved_words[]

static

Initial value:

                                        =
{
   "assert",  "break", "case", "continue", "const",  "default",
   "false", "for", "if", "else", "ilike", "in", "like",  "and",
   "nand",  "nor",  "not",  "null",  "or",  "repeat", "return",
   "shl",  "shr",  "swap",  "switch",  "true",  "until", "var",
   "while", "xnor", "xor", "&", "|"
}

Definition at line 440 of file exprtk.hpp.

                                                    {
         "assert",  "break", "case", "continue", "const",  "default",
         "false", "for", "if", "else", "ilike", "in", "like",  "and",
         "nand",  "nor",  "not",  "null",  "or",  "repeat", "return",
         "shl",  "shr",  "swap",  "switch",  "true",  "until", "var",
         "while", "xnor", "xor", "&", "|"
      };

Referenced by exprtk::parser< Type >::init_precompilation(), is_reserved_word(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

reserved_words_size

const std::size_t exprtk::details::reserved_words_size = sizeof(reserved_words) / sizeof(std::string)

static

Definition at line 449 of file exprtk.hpp.

Referenced by exprtk::parser< Type >::init_precompilation(), is_reserved_word(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

string_range_node< T >::null_value

template<typename T>

std::string exprtk::details::string_range_node< T >::null_value = std::string("")

Definition at line 10500 of file exprtk.hpp.

stringvar_node< T >::null_value

template<typename T>

std::string exprtk::details::stringvar_node< T >::null_value = std::string("")

Definition at line 10414 of file exprtk.hpp.

stringvar_size_node< T >::null_value

template<typename T>

const std::string exprtk::details::stringvar_size_node< T >::null_value = std::string("")

Definition at line 11136 of file exprtk.hpp.

variable_node< T >::null_value

template<typename T>

T exprtk::details::variable_node< T >::null_value = T(std::numeric_limits<T>::quiet_NaN())

Definition at line 8484 of file exprtk.hpp.