exprtk::details Namespace Reference

Namespaces
	loop_unroll
	numeric

Classes
struct	ilesscompare
class	build_string
struct	cs_match
struct	cis_match
struct	set_zero_value_impl
struct	functor_t
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	exprtk_final
struct	range_pack
struct	range_data_type
class	range_interface
class	string_base_node
class	binary_node
class	trinary_node
class	quaternary_node
class	break_exception
class	continue_exception
struct	loop_runtime_checker
class	while_loop_node
class	repeat_until_loop_node
class	for_loop_node
class	while_loop_bc_node
class	repeat_until_loop_bc_node
class	for_loop_bc_node
class	switch_node
class	ivariable
class	vector_node
class	vector_interface
struct	asn_assignment
struct	asn_addassignment
struct	sf_base
struct	memory_context_t
class	generic_function_node
class	string_function_node
class	multimode_genfunction_node
class	return_exception
class	null_igenfunc
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	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
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_T0oT1oT2
struct	nodetype_T0oT1oT2oT3
class	sf3ext_type_node
struct	T0oT1_define
struct	T0oT1oT2_define
struct	T0oT1oT2oT3_define
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 &)
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)
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)
	pod_set_zero_value (float) pod_set_zero_value(double) pod_set_zero_value(long double) template< typename T > inline void set_zero_value(T *data
template<typename T >
void	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	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_return_node (const expression_node< T > *node)
template<typename T >
bool	is_negate_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)
	define_sfop3 (00,(x+y)/z,"(t+t)/t") define_sfop3(01
x y t t *t	define_sfop3 (02,(x+y) - z,"(t+t)-t") define_sfop3(03
x y t t *t x y t t t	define_sfop3 (04,(x - y)+z,"(t-t)+t") define_sfop3(05
x y t t *t x y t t t x y t t t	define_sfop3 (06,(x - y) *z,"(t-t)*t") define_sfop3(07
x y t t *t x y t t t x y t t t x *y t *t t	define_sfop3 (08,(x *y) - z,"(t*t)-t") define_sfop3(09
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t	define_sfop3 (10,(x *y) *z,"(t*t)*t") define_sfop3(11
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t	define_sfop3 (12,(x/y) - z,"(t/t)-t") define_sfop3(13
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	define_sfop3 (14,(x/y) *z,"(t/t)*t") define_sfop3(15
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	x (y+z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	t (t+t)") define_sfop3(16
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	x (y - z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	t (t-t)") define_sfop3(17
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	x (y *z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	t (t *t)") define_sfop3(18
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	x (y/z)
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t	t (t/t)") define_sfop3(19
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t	define_sfop3 (20, x *(y - z),"t*(t-t)") define_sfop3(21
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	define_sfop3 (22, x *(y/z),"t*(t/t)") define_sfop3(23
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	axnb< T, 2 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	define_sfop3 (32,(axnb< T, 3 >(x, y, z))," ") define_sfop3(33
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	axnb< T, 4 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	define_sfop3 (34,(axnb< T, 5 >(x, y, z))," ") define_sfop3(35
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	axnb< T, 6 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	define_sfop3 (36,(axnb< T, 7 >(x, y, z))," ") define_sfop3(37
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	axnb< T, 8 > (x, y, z))
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t	define_sfop3 (38,(axnb< T, 9 >(x, y, z))," ") define_sfop3(39
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x	define_sfop3 (40, x *numeric::log(y) - z,"") define_sfop3(41
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x x	define_sfop3 (42, x *numeric::log10(y) - z,"") define_sfop3(43
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x x x	define_sfop3 (44, x *numeric::sin(y) - z,"") define_sfop3(45
x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t x x x x	define_sfop3 (46, x *numeric::cos(y) - z,"") define_sfop3(47
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)
	exprtk_define_unary_op (abs) exprtk_define_unary_op(acos) exprtk_define_unary_op(acosh) exprtk_define_unary_op(asin) exprtk_define_unary_op(asinh) exprtk_define_unary_op(atan) exprtk_define_unary_op(atanh) exprtk_define_unary_op(ceil) exprtk_define_unary_op(cos) exprtk_define_unary_op(cosh) exprtk_define_unary_op(cot) exprtk_define_unary_op(csc) exprtk_define_unary_op(d2g) exprtk_define_unary_op(d2r) exprtk_define_unary_op(erf) exprtk_define_unary_op(erfc) exprtk_define_unary_op(exp) exprtk_define_unary_op(expm1) exprtk_define_unary_op(floor) exprtk_define_unary_op(frac) exprtk_define_unary_op(g2d) exprtk_define_unary_op(log) exprtk_define_unary_op(log10) exprtk_define_unary_op(log2) exprtk_define_unary_op(log1p) exprtk_define_unary_op(ncdf) exprtk_define_unary_op(neg) exprtk_define_unary_op(notl) exprtk_define_unary_op(pos) exprtk_define_unary_op(r2d) exprtk_define_unary_op(round) exprtk_define_unary_op(sec) exprtk_define_unary_op(sgn) exprtk_define_unary_op(sin) exprtk_define_unary_op(sinc) exprtk_define_unary_op(sinh) exprtk_define_unary_op(sqrt) exprtk_define_unary_op(tan) exprtk_define_unary_op(tanh) exprtk_define_unary_op(trunc) template< typename T > struct opr_base
template<typename T >
T	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)
	synthesis_node_type_define (const T0 &, const T1 &, e_vov) synthesis_node_type_define(const T0 &
const e_voc	synthesis_node_type_define (const T0, const T1 &, e_cov) synthesis_node_type_define(T0 &
const e_voc T1 e_none	synthesis_node_type_define (const T0, const T1, e_none) synthesis_node_type_define(T0 &
const e_voc T1 e_none const e_none	synthesis_node_type_define (const T0, T1 &, e_none) synthesis_node_type_define(const T0 &
const e_voc T1 e_none const e_none T1 e_none	synthesis_node_type_define (T0 &, const T1 &, e_none) template< typename T
	synthesis_node_type_define (const T0 &, const T1 &, const T2 &, e_vovov) synthesis_node_type_define(const T0 &
const T1 const e_vovoc	synthesis_node_type_define (const T0 &, const T1, const T2 &, e_vocov) synthesis_node_type_define(const T0
const T1 const e_vovoc const T1 const T2 e_covov	synthesis_node_type_define (const T0, const T1 &, const T2, e_covoc) synthesis_node_type_define(const T0
const T1 const e_vovoc const T1 const T2 e_covov const const e_none	synthesis_node_type_define (const T0, const T1, const T2 &, e_none) synthesis_node_type_define(const T0 &
const T1 const e_vovoc const T1 const T2 e_covov const const e_none const const e_none	synthesis_node_type_define (T0 &, T1 &, T2 &, e_none) template< typename T
	synthesis_node_type_define (const T0 &, const T1 &, const T2 &, const T3 &, e_vovovov) synthesis_node_type_define(const T0 &
const T1 const T2 const e_vovovoc	synthesis_node_type_define (const T0 &, const T1 &, const T2, const T3 &, e_vovocov) synthesis_node_type_define(const T0 &
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov	synthesis_node_type_define (const T0, const T1 &, const T2 &, const T3 &, e_covovov) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov	synthesis_node_type_define (const T0 &, const T1, const T2 &, const T3, e_vocovoc) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc	synthesis_node_type_define (const T0 &, const T1, const T2, const T3 &, e_vococov) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none	synthesis_node_type_define (const T0, const T1, const T2, const T3 &, e_none) synthesis_node_type_define(const T0
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none	synthesis_node_type_define (const T0, const T1 &, const T2, const T3, e_none) synthesis_node_type_define(const T0 &
const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none const const const e_none	synthesis_node_type_define (const T0, const T1, const T2 &, const T3 &, e_none) synthesis_node_type_define(const T0 &
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)
void	load_operations_map (std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)
template<typename Parser >
void	disable_type_checking (Parser &p)

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)
const std::size_t	size
static const double	pow10 []
static const std::size_t	pow10_size = sizeof(pow10) / sizeof(double)
x y *	z
const	T1
const e_voc T1 e_none const e_none T1 e_none	T0
const T1 const	T2
const T1 const T2 const	T3

Typedef Documentation

_int64_t

typedef long long int exprtk::details::_int64_t

_uint64_t

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

char_cptr

typedef char_t const* exprtk::details::char_cptr

char_ptr

typedef char_t* exprtk::details::char_ptr

char_t

typedef char exprtk::details::char_t

uchar_cptr

typedef uchar_t const* exprtk::details::uchar_cptr

uchar_ptr

typedef uchar_t* exprtk::details::uchar_ptr

uchar_t

typedef unsigned char exprtk::details::uchar_t

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

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

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

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

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

axn()

template<typename T , std::size_t N>

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

inline

axnb()

template<typename T , std::size_t N>

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

inline

axnb< T, 2 >()

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::axnb< T, 2 >	(	x	,
		y	,
		z
	)

axnb< T, 4 >()

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::axnb< T, 4 >	(	x	,
		y	,
		z
	)

axnb< T, 6 >()

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::axnb< T, 6 >	(	x	,
		y	,
		z
	)

axnb< T, 8 >()

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::axnb< T, 8 >	(	x	,
		y	,
		z
	)

back()

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

inline

branch_deletable()

template<typename T >

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

inline

case_normalise()

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

inline

cleanup_escapes()

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

inline

compute_pow10()

template<typename T >

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

inline

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

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

define_sfop3() [1/18]

exprtk::details::define_sfop3	(	00	,
		(x+y)/	z,
		"(t+t)/t"
	)

define_sfop3() [2/18]

x y t t* t exprtk::details::define_sfop3	(	02	,
		(x+y) -	z,
		"(t+t)-t"
	)

define_sfop3() [3/18]

x y t t* t x y t t t exprtk::details::define_sfop3	(	04	,
		(x - y)+	z,
		"(t-t)+t"
	)

define_sfop3() [4/18]

x y t t* t x y t t t x y t t t exprtk::details::define_sfop3	(	06	,
		(x - y) *	z,
		"(t-t)*t"
	)

define_sfop3() [5/18]

x y t t* t x y t t t x y t t t x* y t* t t exprtk::details::define_sfop3	(	08	,
		(x *y) -	z,
		"(t*t)-t"
	)

define_sfop3() [6/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t exprtk::details::define_sfop3	(	10	,
		(x *y) *	z,
		"(t*t)*t"
	)

define_sfop3() [7/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t exprtk::details::define_sfop3	(	12	,
		(x/y) -	z,
		"(t/t)-t"
	)

define_sfop3() [8/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t exprtk::details::define_sfop3	(	14	,
		(x/y) *	z,
		"(t/t)*t"
	)

define_sfop3() [9/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t exprtk::details::define_sfop3	(	20	,
		x *	y - z,
		"t*(t-t)"
	)

define_sfop3() [10/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::define_sfop3	(	22	,
		x *	y/z,
		"t*(t/t)"
	)

define_sfop3() [11/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::define_sfop3	(	32	,
		(axnb< T, 3 >(x, y, z))	,
		" "
	)

define_sfop3() [12/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::define_sfop3	(	34	,
		(axnb< T, 5 >(x, y, z))	,
		" "
	)

define_sfop3() [13/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::define_sfop3	(	36	,
		(axnb< T, 7 >(x, y, z))	,
		" "
	)

define_sfop3() [14/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t exprtk::details::define_sfop3	(	38	,
		(axnb< T, 9 >(x, y, z))	,
		" "
	)

define_sfop3() [15/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t x exprtk::details::define_sfop3	(	40	,
		x *numeric::log(y) -	z,
		""
	)

define_sfop3() [16/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t x x exprtk::details::define_sfop3	(	42	,
		x *numeric::log10(y) -	z,
		""
	)

define_sfop3() [17/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t x x x exprtk::details::define_sfop3	(	44	,
		x *numeric::sin(y) -	z,
		""
	)

define_sfop3() [18/18]

x y t t* t x y t t t x y t t t x* y t* t t x* y t* t t x y t t t x y t t t x* y t* t t x* y t* t* t x x x x exprtk::details::define_sfop3	(	46	,
		x *numeric::cos(y) -	z,
		""
	)

destroy_node()

template<typename T >

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

inline

disable_type_checking()

template<typename Parser >

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

inline

dump_ptr() [1/2]

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

inline

dump_ptr() [2/2]

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

inline

dump_vector()

template<typename T >

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

inline

exprtk_define_unary_op()

exprtk::details::exprtk_define_unary_op

(

abs

)

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

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

free_node()

template<typename NodeAllocator , typename T >

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

inline

front()

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

inline

hex_to_bin()

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

inline

imatch() [1/2]

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

inline

imatch() [2/2]

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

inline

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

is_base_function()

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

inline

is_binary_node()

template<typename T >

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

inline

is_boc_node()

template<typename T >

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

inline

is_bracket()

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

inline

is_break_node()

template<typename T >

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

inline

is_cob_node()

template<typename T >

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

inline

is_const_string_node()

template<typename T >

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

inline

is_const_string_range_node()

template<typename T >

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

inline

is_constant_node()

template<typename T >

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

inline

is_continue_node()

template<typename T >

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

inline

is_control_struct()

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

inline

is_cov_node()

template<typename T >

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

inline

is_digit()

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

inline

is_false() [1/2]

template<typename T >

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

inline

is_false() [2/2]

template<typename T >

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

inline

is_function()

template<typename T >

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

inline

is_generally_string_node()

template<typename T >

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

inline

is_genricstring_range_node()

template<typename T >

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

inline

is_hex_digit()

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

inline

is_invalid()

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

inline

is_ivariable_node()

template<typename T >

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

inline

is_ivector_node()

template<typename T >

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

inline

is_left_bracket()

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

inline

is_letter()

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

inline

is_letter_or_digit()

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

inline

is_literal_node()

template<typename T >

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

inline

is_logic_opr()

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

inline

is_neg_unary_node()

template<typename T >

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

inline

is_negate_node()

template<typename T >

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

inline

is_null_node()

template<typename T >

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

inline

is_operator_char()

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

inline

is_rebasevector_celem_node()

template<typename T >

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

inline

is_rebasevector_celem_rtc_node()

template<typename T >

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

inline

is_rebasevector_elem_node()

template<typename T >

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

inline

is_rebasevector_elem_rtc_node()

template<typename T >

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

inline

is_reserved_symbol()

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

inline

is_reserved_word()

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

inline

is_return_node()

template<typename T >

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

inline

is_right_bracket()

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

inline

is_sf3ext_node()

template<typename T >

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

inline

is_sf4ext_node()

template<typename T >

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

inline

is_sign()

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

inline

is_string_assignment_node()

template<typename T >

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

inline

is_string_ccondition_node()

template<typename T >

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

inline

is_string_concat_node()

template<typename T >

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

inline

is_string_condition_node()

template<typename T >

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

inline

is_string_function_node()

template<typename T >

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

inline

is_string_node()

template<typename T >

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

inline

is_string_range_node()

template<typename T >

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

inline

is_string_vararg_node()

template<typename T >

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

inline

is_swap_node()

template<typename T >

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

inline

is_t0ot1ot2_node()

template<typename T >

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

inline

is_t0ot1ot2ot3_node()

template<typename T >

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

inline

is_true() [1/5]

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

inline

is_true() [2/5]

template<typename T >

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

inline

is_true() [3/5]

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

inline

is_true() [4/5]

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

inline

is_true() [5/5]

template<typename T >

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

inline

is_unary_node()

template<typename T >

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

inline

is_uv_node()

template<typename T >

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

inline

is_valid_sf_symbol()

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

inline

is_valid_string_char()

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

inline

is_variable_node()

template<typename T >

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

inline

is_vector_celem_node()

template<typename T >

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

inline

is_vector_celem_rtc_node()

template<typename T >

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

inline

is_vector_elem_node()

template<typename T >

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

inline

is_vector_elem_rtc_node()

template<typename T >

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

inline

is_vector_node()

template<typename T >

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

inline

is_voc_node()

template<typename T >

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

inline

is_vov_node()

template<typename T >

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

inline

is_whitespace()

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

inline

load_operations_map()

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

inline

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

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

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

parse_hex()

template<typename Iterator >

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

inline

parse_inf()

template<typename Iterator , typename T >

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

inlinestatic

parse_nan()

template<typename Iterator , typename T >

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

inlinestatic

pod_set_zero_value()

exprtk::details::pod_set_zero_value

(

float

)

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

set_zero_value()

template<typename T >

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

inline

string_to_real() [1/2]

template<typename T >

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

inline

string_to_real() [2/2]

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

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

synthesis_node_type_define() [1/18]

exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const T1 &	,
		const T2 &	,
		const T3 &	,
		e_vovovov
	)		const &

synthesis_node_type_define() [2/18]

exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const T1 &	,
		const T2 &	,
		e_vovov
	)		const &

synthesis_node_type_define() [3/18]

const T1 const T2 const e_vovovoc exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const T1 &	,
		const	T2,
		const T3 &	,
		e_vovocov
	)		const &

synthesis_node_type_define() [4/18]

exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const T1 &	,
		e_vov
	)		const &

synthesis_node_type_define() [5/18]

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const	T1,
		const T2 &	,
		const	T3,
		e_vocovoc
	)		const

synthesis_node_type_define() [6/18]

const T1 const e_vovoc exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const	T1,
		const T2 &	,
		e_vocov
	)		const

synthesis_node_type_define() [7/18]

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc exprtk::details::synthesis_node_type_define	(	const T0 &	,
		const	T1,
		const	T2,
		const T3 &	,
		e_vococov
	)		const

synthesis_node_type_define() [8/18]

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov exprtk::details::synthesis_node_type_define	(	const	T0,
		const T1 &	,
		const T2 &	,
		const T3 &	,
		e_covovov
	)		const

synthesis_node_type_define() [9/18]

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none exprtk::details::synthesis_node_type_define	(	const	T0,
		const T1 &	,
		const	T2,
		const	T3,
		e_none
	)		const &

synthesis_node_type_define() [10/18]

const T1 const e_vovoc const T1 const T2 e_covov exprtk::details::synthesis_node_type_define	(	const	T0,
		const T1 &	,
		const	T2,
		e_covoc
	)		const

synthesis_node_type_define() [11/18]

const e_voc exprtk::details::synthesis_node_type_define	(	const	T0,
		const T1 &	,
		e_cov
	)		&

synthesis_node_type_define() [12/18]

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none const const const e_none exprtk::details::synthesis_node_type_define	(	const	T0,
		const	T1,
		const T2 &	,
		const T3 &	,
		e_none
	)		const &

synthesis_node_type_define() [13/18]

const T1 const e_vovoc const T1 const T2 e_covov const const e_none exprtk::details::synthesis_node_type_define	(	const	T0,
		const	T1,
		const T2 &	,
		e_none
	)		const &

synthesis_node_type_define() [14/18]

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none exprtk::details::synthesis_node_type_define	(	const	T0,
		const	T1,
		const	T2,
		const T3 &	,
		e_none
	)		const

synthesis_node_type_define() [15/18]

const e_voc T1 e_none exprtk::details::synthesis_node_type_define	(	const	T0,
		const	T1,
		e_none
	)		&

synthesis_node_type_define() [16/18]

const e_voc T1 e_none const e_none exprtk::details::synthesis_node_type_define	(	const	T0,
		T1 &	,
		e_none
	)		const &

synthesis_node_type_define() [17/18]

const e_voc T1 e_none const e_none T1 e_none exprtk::details::synthesis_node_type_define	(	T0 &	,
		const T1 &	,
		e_none
	)

synthesis_node_type_define() [18/18]

const T1 const e_vovoc const T1 const T2 e_covov const const e_none const const e_none exprtk::details::synthesis_node_type_define	(	T0 &	,
		T1 &	,
		T2 &	,
		e_none
	)

t() [1/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::t

(

t *

t

)

t() [2/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::t

(

t+

t

)

t() [3/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::t

(

t-

t

)

t() [4/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::t

(

t/

t

)

to_str() [1/3]

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

inline

to_str() [2/3]

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

inline

to_str() [3/3]

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

inline

valid_exponent()

template<typename T >

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

inline

value() [1/4]

template<typename T >

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

inline

value() [2/4]

template<typename T >

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

inline

value() [3/4]

template<typename T >

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

inline

value() [4/4]

template<typename T >

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

inline

wc_imatch()

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

inline

wc_match()

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

inline

x() [1/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::x

(

y *

z

)

x() [2/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::x

(

y -

z

)

x() [3/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::x

(

y+

z

)

x() [4/4]

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y t *t *t exprtk::details::x

(

y/

z

)

Variable Documentation

arithmetic_ops_list

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

static

Initial value:

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

arithmetic_ops_list_size

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

static

assignment_ops_list

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

static

Initial value:

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

assignment_ops_list_size

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

static

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"
      }

base_function_list_size

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

static

cntrl_struct_list

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

static

Initial value:

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

cntrl_struct_list_size

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

static

inequality_ops_list

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

static

Initial value:

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

inequality_ops_list_size

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

static

logic_ops_list

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

static

Initial value:

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

logic_ops_list_size

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

static

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
      }

pow10_size

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

static

reserved_symbols

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

static

Initial value:

=
      {
         "abs",  "acos",  "acosh",  "and",  "asin",  "asinh", "atan",
         "atanh", "atan2", "avg",  "break", "case", "ceil",  "clamp",
         "continue",   "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", "&", "|"
      }

reserved_symbols_size

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

static

reserved_words

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

static

Initial value:

=
      {
         "break",  "case",  "continue",  "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", "&", "|"
      }

reserved_words_size

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

static

size

const std::size_t exprtk::details::size

Initial value:

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

T0

const T1 const e_vovoc const T1 const T2 e_covov const const e_none const const e_none exprtk::details::T0

T1

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none const exprtk::details::T1

T2

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none const const const e_none const T1 const exprtk::details::T2

T3

const T1 const T2 const e_vovovoc const const T2 const T3 e_vocovov const T1 const const T3 e_covocov const T1 const T2 const e_covovoc const const const e_none const const T2 const e_none const const const e_none const T1 const const exprtk::details::T3

z

x y t t *t x y t t t x y t t t x *y t *t t x *y t *t t x y t t t x y t t t x *y t *t t x *y * exprtk::details::z