exprtk::details Namespace Reference

Namespaces
namespace	loop_unroll
namespace	numeric

Classes
struct	add_op
struct	and_op
struct	asn_addassignment
struct	asn_assignment
class	assignment_node
class	assignment_op_node
class	assignment_rebasevec_celem_node
class	assignment_rebasevec_celem_op_node
class	assignment_rebasevec_elem_node
class	assignment_rebasevec_elem_op_node
class	assignment_string_node
class	assignment_string_range_node
class	assignment_vec_elem_node
class	assignment_vec_elem_op_node
class	assignment_vec_node
class	assignment_vec_op_node
class	assignment_vecvec_node
class	assignment_vecvec_op_node
struct	base_operation_t
class	binary_ext_node
class	binary_node
class	bipow_node
class	bipowninv_node
class	boc_base_node
class	boc_node
class	bov_base_node
class	bov_node
class	break_exception
class	break_node
class	build_string
struct	cis_match
class	cob_base_node
class	cob_node
struct	collector_helper
class	conditional_node
class	conditional_string_node
class	cons_conditional_node
class	cons_conditional_str_node
class	const_string_range_node
class	continue_exception
class	continue_node
class	cov_base_node
class	cov_node
struct	cs_match
struct	div_op
struct	eq_op
struct	equal_op
class	expression_node
class	for_loop_bc_node
class	for_loop_node
class	function_N_node
class	function_N_node< T, IFunction, 0 >
struct	functor_t
class	generic_function_node
class	generic_string_range_node
struct	gt_op
struct	gte_op
struct	ilesscompare
struct	ilike_op
struct	in_op
struct	inrange_op
class	ipow_node
class	ipowinv_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< const T & >
struct	is_ref< T & >
class	ivariable
struct	like_op
class	literal_node
struct	loop_runtime_checker
struct	lt_op
struct	lte_op
struct	mod_op
struct	mul_op
class	multi_switch_node
class	multimode_genfunction_node
class	multimode_strfunction_node
struct	nand_op
struct	ne_op
class	node_allocator
class	node_collection_destructor
struct	node_collector_interface
struct	node_depth_base
struct	nodetype_T0oT1
struct	nodetype_T0oT1oT2
struct	nodetype_T0oT1oT2oT3
struct	nor_op
class	null_eq_node
class	null_igenfunc
class	null_node
struct	or_op
struct	param_to_str
struct	param_to_str< 0 >
struct	pow_op
class	quaternary_node
struct	range_data_type
class	range_interface
struct	range_pack
class	rebasevector_celem_node
class	rebasevector_elem_node
class	repeat_until_loop_bc_node
class	repeat_until_loop_node
class	return_envelope_node
class	return_exception
class	return_node
class	scand_node
class	scor_node
class	sf3_var_node
class	sf3ext_type_node
class	sf4_node
class	sf4_var_node
struct	sf_base
class	sos_base_node
class	sos_node
class	sosos_base_node
class	sosos_node
class	str_sogens_node
class	str_vararg_node
class	str_xoxr_node
class	str_xrox_node
class	str_xroxr_node
class	string_base_node
class	string_concat_node
class	string_function_node
class	string_literal_node
class	string_range_node
class	string_size_node
class	stringvar_node
class	stringvar_size_node
struct	sub_op
class	swap_generic_node
class	swap_genstrings_node
class	swap_node
class	swap_string_node
class	swap_vecvec_node
class	switch_n_node
class	switch_node
class	T0oT1
struct	T0oT1_define
class	T0oT1oT2
struct	T0oT1oT20T3process
class	T0oT1oT2_base_node
struct	T0oT1oT2_define
class	T0oT1oT2_sf3
class	T0oT1oT2_sf3ext
class	T0oT1oT2oT3
class	T0oT1oT2oT3_base_node
struct	T0oT1oT2oT3_define
class	T0oT1oT2oT3_sf4
class	T0oT1oT2oT3_sf4ext
struct	T0oT1oT2process
class	trinary_node
class	unary_branch_node
class	unary_node
class	unary_variable_node
class	unary_vector_node
class	uv_base_node
class	uvouv_node
struct	vararg_add_op
struct	vararg_avg_op
class	vararg_function_node
struct	vararg_mand_op
struct	vararg_max_op
struct	vararg_min_op
struct	vararg_mor_op
struct	vararg_mul_op
struct	vararg_multi_op
class	vararg_node
class	vararg_varnode
class	variable_node
struct	vec_add_op
struct	vec_avg_op
class	vec_binop_valvec_node
class	vec_binop_vecval_node
class	vec_binop_vecvec_node
class	vec_data_store
struct	vec_max_op
struct	vec_min_op
struct	vec_mul_op
class	vector_assignment_node
class	vector_elem_node
class	vector_holder
class	vector_interface
class	vector_node
class	vectorize_node
class	vob_base_node
class	vob_node
class	voc_base_node
class	voc_node
class	vov_base_node
class	vov_node
class	while_loop_bc_node
class	while_loop_node
struct	xnor_op
struct	xor_op

Typedefs
typedef unsigned char	uchar_t
typedef char	char_t
typedef uchar_t *	uchar_ptr
typedef char_t *	char_ptr
typedef uchar_t const *	uchar_cptr
typedef char_t const *	char_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)
std::string	to_str (int i)
std::string	to_str (std::size_t i)
bool	is_hex_digit (const std::string::value_type digit)
uchar_t	hex_to_bin (uchar_t h)
template<typename Iterator >
bool	parse_hex (Iterator &itr, Iterator end, std::string::value_type &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 &zero_or_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 >
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, 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 >
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 std::complex< T > &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_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_rebasevector_elem_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 (expression_node< T > *node)
template<std::size_t N, typename T >
bool	all_nodes_valid (expression_node< T > *(&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 > *(&b)[N])
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	all_nodes_variables (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 (T a, T x)
template<typename T , std::size_t N>
T	axnb (T a, T x, 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
	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)
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

References b.

all_nodes_valid() [2/2]

template<std::size_t N, typename T >

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

inline

References b.

all_nodes_variables() [1/2]

template<std::size_t N, typename T >

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

inline

References b, and is_variable_node().

all_nodes_variables() [2/2]

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

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

inline

References b, and is_variable_node().

axn()

template<typename T , std::size_t N>

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

inline

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

axnb()

template<typename T , std::size_t N>

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

inline

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

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 ( expression_node< T > *  node )

inline

References is_string_node(), and is_variable_node().

Referenced by exprtk::details::node_depth_base< Node >::collect(), exprtk::parser< T >::compile(), construct_branch_pair(), exprtk::details::generic_function_node< T, GenericFunction >::init_branches(), and exprtk::details::function_N_node< T, IFunction, N >::init_branches().

case_normalise()

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

inline

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

cleanup_escapes()

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

inline

References parse_hex().

compute_pow10()

template<typename T >

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

inline

References exprtk::details::numeric::constant::e, and exprtk::details::numeric::pow().

Referenced by string_to_real().

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

References b, and branch_deletable().

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

References b, branch_deletable(), and index.

Referenced by exprtk::details::bipow_node< T, PowOp >::bipow_node(), exprtk::details::bipowninv_node< T, PowOp >::bipowninv_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::cons_conditional_node< T >::cons_conditional_node(), exprtk::details::for_loop_bc_node< T >::for_loop_bc_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_elem_node< T >::rebasevector_elem_node(), exprtk::details::repeat_until_loop_bc_node< T >::repeat_until_loop_bc_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_elem_node< T >::vector_elem_node(), exprtk::details::vectorize_node< T, VecFunction >::vectorize_node(), exprtk::details::vob_node< T, Operation >::vob_node(), exprtk::details::while_loop_bc_node< T >::while_loop_bc_node(), and exprtk::details::while_loop_node< T >::while_loop_node().

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

References exprtk::details::numeric::process(), exprtk::details::trinary_node< T >::value(), value(), x(), and z.

destroy_node()

template<typename T >

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

inline

Referenced by exprtk::parser< T >::compile(), and exprtk::details::range_pack< T >::free().

disable_type_checking()

template<typename Parser >

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

inline

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

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

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

References b, and free_node().

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

References b, and free_node().

free_node()

template<typename NodeAllocator , typename T >

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

inline

References is_string_node(), and is_variable_node().

Referenced by free_all_nodes().

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

Referenced by parse_hex().

imatch() [1/2]

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

inline

Referenced by exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), 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::lexer::parser_helper::peek_token_is(), and exprtk::lexer::parser_helper::token_is().

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

References construct_branch_pair().

is_base_function()

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

inline

References base_function_list, base_function_list_size, and imatch().

is_binary_node()

template<typename T >

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

inline

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

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

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

References is_left_bracket(), and is_right_bracket().

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

is_break_node()

template<typename T >

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

inline

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

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

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

is_const_string_range_node()

template<typename T >

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

inline

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

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

is_constant_node()

template<typename T >

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

inline

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

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

is_continue_node()

template<typename T >

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

inline

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

is_control_struct()

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

inline

References cntrl_struct_list, cntrl_struct_list_size, and imatch().

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

Referenced by is_invalid(), is_letter_or_digit(), and is_valid_sf_symbol().

is_false() [1/2]

template<typename T >

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

inline

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

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

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

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

Referenced by exprtk::expression_helper< T >::is_function(), and testing::internal::PrintTo().

is_generally_string_node()

template<typename T >

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

inline

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

Referenced by 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, GenericFunction >::init_branches(), 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(), and exprtk::details::swap_genstrings_node< T >::swap_genstrings_node().

is_genricstring_range_node()

template<typename T >

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

inline

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

is_hex_digit()

bool exprtk::details::is_hex_digit ( const std::string::value_type  digit )

inline

Referenced by parse_hex().

is_invalid()

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

inline

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

is_ivariable_node()

template<typename T >

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

inline

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

is_ivector_node()

template<typename T >

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

inline

References 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::generic_function_node< T, GenericFunction >::init_branches(), exprtk::details::swap_vecvec_node< T >::swap_vecvec_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(), exprtk::details::vec_binop_vecvec_node< T, Operation >::vec_binop_vecvec_node(), and exprtk::details::vectorize_node< T, VecFunction >::vectorize_node().

is_left_bracket()

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

inline

Referenced by is_bracket().

is_letter()

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

inline

Referenced by is_invalid(), and is_letter_or_digit().

is_letter_or_digit()

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

inline

References is_digit(), and is_letter().

is_logic_opr()

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

inline

References imatch(), logic_ops_list, and logic_ops_list_size.

is_neg_unary_node()

template<typename T >

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

inline

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

is_negate_node()

template<typename T >

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

inline

References e_neg, and is_unary_node().

is_null_node()

template<typename T >

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

inline

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

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

is_operator_char()

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

inline

Referenced by is_invalid().

is_rebasevector_celem_node()

template<typename T >

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

inline

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

Referenced by exprtk::details::assignment_rebasevec_celem_node< T >::assignment_rebasevec_celem_node(), and exprtk::details::assignment_rebasevec_celem_op_node< T, Operation >::assignment_rebasevec_celem_op_node().

is_rebasevector_elem_node()

template<typename T >

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

inline

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

Referenced by exprtk::details::assignment_rebasevec_elem_node< T >::assignment_rebasevec_elem_node(), and exprtk::details::assignment_rebasevec_elem_op_node< T, Operation >::assignment_rebasevec_elem_op_node().

is_reserved_symbol()

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

inline

References imatch(), reserved_symbols, and reserved_symbols_size.

Referenced by exprtk::symbol_table< T >::symbol_exists().

is_reserved_word()

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

inline

References imatch(), reserved_words, and reserved_words_size.

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

is_return_node()

template<typename T >

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

inline

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

is_right_bracket()

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

inline

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

is_sf3ext_node()

template<typename T >

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

inline

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

is_sf4ext_node()

template<typename T >

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

inline

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

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

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

is_string_ccondition_node()

template<typename T >

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

inline

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

is_string_concat_node()

template<typename T >

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

inline

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

is_string_condition_node()

template<typename T >

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

inline

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

is_string_function_node()

template<typename T >

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

inline

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

is_string_node()

template<typename T >

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

inline

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

Referenced by exprtk::details::assignment_string_node< T, AssignmentProcess >::assignment_string_node(), branch_deletable(), exprtk::details::range_pack< T >::free(), free_node(), and exprtk::details::swap_string_node< T >::swap_string_node().

is_string_range_node()

template<typename T >

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

inline

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

Referenced by exprtk::details::assignment_string_range_node< T, AssignmentProcess >::assignment_string_range_node().

is_string_vararg_node()

template<typename T >

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

inline

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

is_swap_node()

template<typename T >

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

inline

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

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

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

inline

Referenced by exprtk::expression< T >::operator bool(), exprtk::pgo_primer(), exprtk::details::and_op< T >::process(), exprtk::details::nand_op< T >::process(), exprtk::details::or_op< T >::process(), exprtk::details::nor_op< T >::process(), exprtk::details::conditional_node< T >::value(), exprtk::details::cons_conditional_node< T >::value(), exprtk::details::while_loop_node< T >::value(), exprtk::details::for_loop_node< T >::value(), exprtk::details::while_loop_bc_node< T >::value(), exprtk::details::for_loop_bc_node< T >::value(), exprtk::details::switch_node< T >::value(), exprtk::details::multi_switch_node< T >::value(), exprtk::details::conditional_string_node< T >::value(), and exprtk::details::cons_conditional_str_node< T >::value().

is_true() [2/6]

template<typename T >

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

inline

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

is_true() [3/6]

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

inline

is_true() [4/6]

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

inline

is_true() [5/6]

template<typename T >

bool exprtk::details::is_true ( const std::complex< T > &  v )

inline

is_true() [6/6]

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

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

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

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

References imatch(), and is_digit().

is_valid_string_char()

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

inline

References is_whitespace().

is_variable_node()

template<typename T >

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

inline

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

Referenced by all_nodes_variables(), exprtk::details::assignment_node< T >::assignment_node(), exprtk::details::assignment_op_node< T, Operation >::assignment_op_node(), branch_deletable(), exprtk::details::vararg_function_node< T, VarArgFunction >::collect_nodes(), exprtk::details::range_pack< T >::free(), free_node(), exprtk::details::generic_function_node< T, GenericFunction >::init_branches(), exprtk::expression_helper< T >::is_variable(), and exprtk::details::vararg_varnode< T, VarArgFunction >::vararg_varnode().

is_vector_elem_node()

template<typename T >

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

inline

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

Referenced by exprtk::details::assignment_vec_elem_node< T >::assignment_vec_elem_node(), and exprtk::details::assignment_vec_elem_op_node< T, Operation >::assignment_vec_elem_op_node().

is_vector_node()

template<typename T >

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

inline

References 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::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().

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

Referenced by is_invalid(), and is_valid_string_char().

load_operations_map()

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

inline

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.

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

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

inline

References Opm::EclIO::cmp().

parse_hex()

template<typename Iterator >

bool exprtk::details::parse_hex ( Iterator &  itr, Iterator  end, std::string::value_type &  result  )

inline

References hex_to_bin(), and is_hex_digit().

Referenced by cleanup_escapes().

parse_inf()

template<typename Iterator , typename T >

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

inlinestatic

References length, and t().

Referenced by string_to_real().

parse_nan()

template<typename Iterator , typename T >

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

inlinestatic

References t().

Referenced by string_to_real().

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

string_to_real() [1/2]

template<typename T >

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

inline

References Catch::begin, string_to_real(), and t().

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

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

Referenced by exprtk::lexer::helper::numeric_checker::operator()(), and string_to_real().

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

References exprtk_disable_fallthrough_begin, exprtk_disable_fallthrough_end, exprtk_process_digit, and length.

Referenced by string_to_real().

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

)

Referenced by exprtk::details::numeric::details::exprtk_define_erf(), Opm::ParameterRequirementAnd< Requirement1, Requirement2 >::operator()(), Opm::operator<<(), parse_inf(), parse_nan(), testing::internal::PrintTo(), testing::internal::PrintTupleTo(), string_to_real(), testing::internal::TersePrintPrefixToStrings(), Opm::uppercase(), and value().

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

)

Referenced by exprtk::symbol_table< T >::type_store< Type, RawType >::add(), exprtk::symbol_table< T >::add_constant(), exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), exprtk::symbol_table< T >::add_variable(), exprtk::symbol_table< T >::create_variable(), exprtk::lexer::helper::dump(), exprtk::lexer::generator::insert_front(), exprtk::lexer::helper::operator_joiner::join(), exprtk::parser_error::make_error(), exprtk::lexer::helper::bracket_checker::operator()(), exprtk::lexer::helper::numeric_checker::operator()(), exprtk::rtl::io::file::open< T >::operator()(), exprtk::lexer::token_scanner::process(), exprtk::lexer::token_inserter::process(), exprtk::lexer::helper::bracket_checker::result(), and exprtk::lexer::token::to_str().

to_str() [1/3]

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

inline

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

References string.

Referenced by to_str().

to_str() [3/3]

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

inline

References to_str().

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

References t().

Referenced by exprtk::symbol_table< T >::add_constant(), exprtk::symbol_table< T >::add_epsilon(), exprtk::symbol_table< T >::create_stringvar(), exprtk::symbol_table< T >::create_variable(), exprtk::details::numeric::details::equal_impl(), exprtk::details::numeric::details::nequal_impl(), exprtk::expression< T >::operator bool(), exprtk::expression< T >::operator T(), exprtk::expression< T >::operator()(), exprtk::parser< T >::process_lexer_errors(), and exprtk::lexer::parser_helper::token_is().

value() [2/4]

template<typename T >

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

inline

References t().

value() [3/4]

template<typename T >

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

inline

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

Referenced by NRLib::RegularSurface< A >::AddNonConform(), NRLib::RegularSurfaceRotated< A >::AddNonConform(), Catch::StringMaker< T, typename >::convert(), Opm::ParameterMapItemTrait< int >::convert(), Opm::ParameterMapItemTrait< double >::convert(), Catch::Detail::convertUnstreamable(), Opm::IOrderSet< T >::count(), Opm::FieldProps::FieldData< T >::default_assign(), testing_internal::DefaultPrintNonContainerTo(), testing::internal::DefaultPrintTo(), define_sfop3(), Opm::UniformTableLinear< T >::derivative(), NRLib::RegularSurface< A >::DivideNonConform(), NRLib::RegularSurfaceRotated< A >::DivideNonConform(), Opm::IOrderSet< T >::erase(), Opm::DynamicState< T >::find(), Opm::DynamicState< T >::find_not(), testing::internal::FormatForComparison< ToPrint, OtherOperand >::Format(), testing::internal::FormatForComparison< ToPrint[N], OtherOperand >::Format(), testing::internal::FormatForComparisonFailureMessage(), Opm::Serializer::get(), testing::internal::FlatTuple< T >::Get(), Opm::ParameterGroup::get(), Opm::Serializer::get_map(), NRLib::Grid< A >::GetAvgMinMax(), NRLib::Grid< A >::GetAvgMinMaxWithMissing(), Opm::DynamicState< T >::globalReset(), Opm::IOrderSet< T >::insert(), Opm::DynamicVector< T >::iset(), riOctavePlugin::isOctaveValueNumeric(), NRLib::Grid< A >::LogTransform(), NRLib::RegularSurface< A >::MultiplyNonConform(), NRLib::RegularSurfaceRotated< A >::MultiplyNonConform(), Catch::Detail::Approx::operator()(), Catch::operator+(), Catch::MessageStream::operator<<(), Catch::MessageBuilder::operator<<(), Catch::ReusableStringStream::operator<<(), Catch::Decomposer::operator<=(), ClipperLib::ClipperBase::PreserveCollinear(), testing::internal::UniversalPrinter< T >::Print(), testing::internal::UniversalPrinter< T & >::Print(), testing::internal::UniversalTersePrinter< T >::Print(), testing::internal::UniversalTersePrinter< T & >::Print(), testing::internal::UniversalTersePrinter< T[N]>::Print(), testing::internal::PrintTo(), testing::PrintToString(), testing::internal2::TypeWithoutFormatter< T, kTypeKind >::PrintValue(), testing::internal2::TypeWithoutFormatter< T, kProtobuf >::PrintValue(), testing::internal2::TypeWithoutFormatter< T, kConvertibleToInteger >::PrintValue(), exprtk::details::vararg_add_op< T >::process(), exprtk::details::vararg_mul_op< T >::process(), exprtk::details::vararg_min_op< T >::process(), exprtk::details::vararg_max_op< T >::process(), exprtk::details::vararg_mand_op< T >::process(), exprtk::details::vararg_mor_op< T >::process(), exprtk::details::vararg_multi_op< T >::process(), exprtk::details::vararg_add_op< T >::process_1(), exprtk::details::vararg_mul_op< T >::process_1(), exprtk::details::vararg_avg_op< T >::process_1(), exprtk::details::vararg_min_op< T >::process_1(), exprtk::details::vararg_max_op< T >::process_1(), exprtk::details::vararg_mand_op< T >::process_1(), exprtk::details::vararg_mor_op< T >::process_1(), exprtk::details::vararg_multi_op< T >::process_1(), exprtk::details::vararg_add_op< T >::process_2(), exprtk::details::vararg_mul_op< T >::process_2(), exprtk::details::vararg_avg_op< T >::process_2(), exprtk::details::vararg_min_op< T >::process_2(), exprtk::details::vararg_max_op< T >::process_2(), exprtk::details::vararg_mand_op< T >::process_2(), exprtk::details::vararg_mor_op< T >::process_2(), exprtk::details::vararg_multi_op< T >::process_2(), exprtk::details::vararg_add_op< T >::process_3(), exprtk::details::vararg_mul_op< T >::process_3(), exprtk::details::vararg_avg_op< T >::process_3(), exprtk::details::vararg_min_op< T >::process_3(), exprtk::details::vararg_max_op< T >::process_3(), exprtk::details::vararg_mand_op< T >::process_3(), exprtk::details::vararg_mor_op< T >::process_3(), exprtk::details::vararg_multi_op< T >::process_3(), exprtk::details::vararg_add_op< T >::process_4(), exprtk::details::vararg_mul_op< T >::process_4(), exprtk::details::vararg_avg_op< T >::process_4(), exprtk::details::vararg_min_op< T >::process_4(), exprtk::details::vararg_max_op< T >::process_4(), exprtk::details::vararg_mand_op< T >::process_4(), exprtk::details::vararg_mor_op< T >::process_4(), exprtk::details::vararg_multi_op< T >::process_4(), exprtk::details::vararg_add_op< T >::process_5(), exprtk::details::vararg_mul_op< T >::process_5(), exprtk::details::vararg_avg_op< T >::process_5(), exprtk::details::vararg_min_op< T >::process_5(), exprtk::details::vararg_max_op< T >::process_5(), exprtk::details::vararg_mand_op< T >::process_5(), exprtk::details::vararg_mor_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(), exprtk::details::vararg_multi_op< T >::process_8(), Opm::Serializer::put(), Opm::data::SegmentPressures::read(), NRLib::RegularSurfaceRotated< A >::RegularSurfaceRotated(), NRLib::RegularSurfaceRotated< A >::ResampleSurface(), NRLib::RegularSurface< A >::Resize(), NRLib::RegularSurfaceRotated< A >::Resize(), ClipperLib::Clipper::ReverseSolution(), Opm::cmp::scalar_equal(), testing::internal::ThreadLocal< T >::set(), Opm::data::Rates::set(), NRLib::Well::SetMissing(), NRLib::Grid< A >::SetValue(), Opm::Value< T >::setValue(), testing::StaticAssertTypeEq(), ClipperLib::Clipper::StrictlySimple(), NRLib::RegularSurface< A >::SubtractNonConform(), NRLib::RegularSurfaceRotated< A >::SubtractNonConform(), testing::internal::UniversalPrint(), testing::internal::UniversalTersePrint(), testing::internal::UniversalTersePrintTupleFieldsToStrings(), Opm::DynamicState< T >::update(), Opm::FieldProps::FieldData< T >::update(), Opm::DynamicState< T >::update_elm(), Opm::DynamicState< T >::update_equal(), Opm::Value< T >::Value(), vector_util_index(), and Opm::data::SegmentPressures::write().

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

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

wc_match()

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

inline

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

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

)

Referenced by NRLib::RegularSurface< A >::AddNonConform(), NRLib::RegularSurfaceRotated< A >::AddNonConform(), axn(), axnb(), NRLib::BlockWell(), Opm::bracketZero(), Opm::buildUniformMonotoneTable(), Opm::Interp1D::PiecewisePolynomial::Linear< Extrapolation, IsAscendingRange >::classifyPoint(), Opm::fun::concat(), define_sfop3(), Opm::NonuniformTableLinear< T >::derivative(), Opm::UniformTableLinear< T >::derivative(), NRLib::RegularSurface< A >::DivideNonConform(), NRLib::RegularSurfaceRotated< A >::DivideNonConform(), Opm::ECLPVT::extractRawPVTCurve(), NRLib::RegularSurface< A >::FindContIndex(), NRLib::RegularSurface< A >::FindGeneralIndex(), NRLib::RegularSurface< A >::FindI(), NRLib::RegularSurface< A >::FindIndex(), NRLib::RegularSurface< A >::FindNearestNodeIndex(), testing::internal::FloatingPoint< RawType >::FloatingPoint(), Opm::ECLPVT::PVTx< SubtableInterpolant >::formationVolumeFactor(), NRLib::RegularSurface< A >::GetCorners(), NRLib::RegularSurface< A >::GetNode(), NRLib::RegularSurface< A >::GetXY(), NRLib::RegularSurfaceRotated< A >::GetXY(), NRLib::Volume::GetXYFromRelative(), NRLib::RegularSurface< A >::GetZ(), NRLib::RegularSurfaceRotated< A >::GetZ(), NRLib::RegularSurface< A >::GetZInside(), NRLib::RegularSurfaceRotated< A >::GetZInside(), testing::internal::ImplicitCast_(), NRLib::RegularSurface< A >::IsInsideSurface(), NRLib::RegularSurfaceRotated< A >::IsInsideSurface(), NRLib::IsType(), Opm::linearInterpolation(), Opm::linearInterpolationDerivative(), Opm::linearInterpolationNoExtrapolation(), NRLib::RegularSurface< A >::MultiplyNonConform(), NRLib::RegularSurfaceRotated< A >::MultiplyNonConform(), Opm::NonuniformTableLinear< T >::operator()(), Opm::UniformTableLinear< T >::operator()(), Opm::ParameterRequirementNonEmpty::operator()(), Opm::ParameterRequirementMemberOf::operator()(), Opm::ParameterRequirementPositive::operator()(), Opm::ParameterRequirementNegative::operator()(), Opm::ParameterRequirementNonPositive::operator()(), Opm::ParameterRequirementNonNegative::operator()(), Opm::ParameterRequirementNonZero::operator()(), Opm::MonotCubicInterpolator::operator()(), Opm::ParameterRequirementProbability::operator()(), NRLib::ParseType(), NRLib::RegularSurfaceRotated< A >::ResampleSurface(), NRLib::RegularSurface< A >::SubtractNonConform(), NRLib::RegularSurfaceRotated< A >::SubtractNonConform(), Opm::tableIndex(), Opm::tag_name(), Opm::uppercase(), exprtk::details::sf4_node< T, SpecialFunction >::value(), and Opm::ECLPVT::PVTx< SubtableInterpolant >::viscosity().

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

)

Referenced by exprtk::compute(), exprtk::derivative(), exprtk::integrate(), exprtk::rtl::vecops::details::kahan_sum(), exprtk::rtl::vecops::copy< T >::operator()(), exprtk::rtl::vecops::axpy< T >::operator()(), exprtk::rtl::vecops::axpby< T >::operator()(), exprtk::rtl::vecops::axpyz< T >::operator()(), exprtk::rtl::vecops::axpbyz< T >::operator()(), exprtk::rtl::vecops::axpbz< T >::operator()(), exprtk::rtl::vecops::dot< T >::operator()(), exprtk::rtl::vecops::dotk< T >::operator()(), exprtk::polynomial< T, N >::operator()(), exprtk::pgo_primer(), exprtk::second_derivative(), and exprtk::third_derivative().

Variable Documentation

arithmetic_ops_list

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

static

Initial value:

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

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

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:

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

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

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

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

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

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

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:

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

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

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

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

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

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
                                    }

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

pow10_size

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

static

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

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

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

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:

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

Referenced by exprtk::parser< T >::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

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

T0

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

Referenced by exprtk::details::T0oT1oT2process< T >::mode0::id(), exprtk::details::T0oT1oT2process< T >::mode1::id(), exprtk::details::T0oT1oT20T3process< T >::mode0::id(), exprtk::details::T0oT1oT20T3process< T >::mode1::id(), exprtk::details::T0oT1oT20T3process< T >::mode2::id(), exprtk::details::T0oT1oT20T3process< T >::mode3::id(), and exprtk::details::T0oT1oT20T3process< T >::mode4::id().

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

Referenced by exprtk::details::T0oT1oT2process< T >::mode0::id(), exprtk::details::T0oT1oT2process< T >::mode1::id(), 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(), and testing::internal::UniversalPrint().

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

Referenced by exprtk::details::T0oT1oT2process< T >::mode0::id(), exprtk::details::T0oT1oT2process< T >::mode1::id(), exprtk::details::T0oT1oT20T3process< T >::mode0::id(), exprtk::details::T0oT1oT20T3process< T >::mode1::id(), exprtk::details::T0oT1oT20T3process< T >::mode2::id(), exprtk::details::T0oT1oT20T3process< T >::mode3::id(), and exprtk::details::T0oT1oT20T3process< T >::mode4::id().

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

Referenced by exprtk::details::T0oT1oT20T3process< T >::mode0::id(), exprtk::details::T0oT1oT20T3process< T >::mode1::id(), exprtk::details::T0oT1oT20T3process< T >::mode2::id(), exprtk::details::T0oT1oT20T3process< T >::mode3::id(), and exprtk::details::T0oT1oT20T3process< T >::mode4::id().

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

Referenced by NRLib::BlockWell(), exprtk::compute(), define_sfop3(), NRLib::RegularSurface< A >::GetNode(), NRLib::RegularSurfaceRotated< A >::GetZ(), NRLib::RegularSurfaceRotated< A >::GetZInside(), NRLib::RegularSurfaceRotated< A >::IsInsideSurface(), exprtk::rtl::vecops::axpyz< T >::operator()(), exprtk::rtl::vecops::axpbyz< T >::operator()(), exprtk::rtl::vecops::axpbz< T >::operator()(), exprtk::pgo_primer(), NRLib::ReadMulticolumnAsciiSurf(), and exprtk::details::sf4_node< T, SpecialFunction >::value().