HyTeG
Matrix-Free Finite Elements
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
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 long long int _int64_t
 
typedef unsigned long long int _uint64_t
 
typedef char_t const * char_cptr
 
typedef char_t * char_ptr
 
typedef char char_t
 
typedef uchar_t const * uchar_cptr
 
typedef uchar_t * uchar_ptr
 
typedef unsigned char uchar_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

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_valid (expression_node< T > *(&b)[N])
 
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 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)
 
x y t t *t x y t t t x y t t t x *y t *t t x *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 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 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 axnb< T, 8 > (x, y, z))
 
const char_t & back (const std::string &s)
 
template<typename T >
bool branch_deletable (expression_node< T > *node)
 
void case_normalise (std::string &s)
 
bool cleanup_escapes (std::string &s)
 
template<typename T >
T compute_pow10 (T d, const int exponent)
 
template<typename T >
void construct_branch_pair (std::pair< expression_node< T > *, bool > &branch, expression_node< T > *b)
 
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)
 
 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 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 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 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 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 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 >
void destroy_node (expression_node< T > *&node)
 
template<typename Parser >
void disable_type_checking (Parser &p)
 
void dump_ptr (const std::string &, const void *)
 
void dump_ptr (const std::string &, const void *, const std::size_t)
 
 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 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)
 
const char_t & front (const std::string &s)
 
uchar_t hex_to_bin (uchar_t h)
 
bool imatch (const char_t c1, const char_t c2)
 
bool imatch (const std::string &s1, const std::string &s2)
 
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))
 
bool is_base_function (const std::string &function_name)
 
template<typename T >
bool is_binary_node (const expression_node< T > *node)
 
template<typename T >
bool is_boc_node (const expression_node< T > *node)
 
bool is_bracket (const char_t c)
 
template<typename T >
bool is_break_node (const expression_node< T > *node)
 
template<typename T >
bool is_cob_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_constant_node (const expression_node< T > *node)
 
template<typename T >
bool is_continue_node (const expression_node< T > *node)
 
bool is_control_struct (const std::string &cntrl_strct)
 
template<typename T >
bool is_cov_node (const expression_node< T > *node)
 
bool is_digit (const char_t c)
 
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_function (const expression_node< T > *node)
 
template<typename T >
bool is_generally_string_node (const expression_node< T > *node)
 
template<typename T >
bool is_genricstring_range_node (const expression_node< T > *node)
 
bool is_hex_digit (const std::string::value_type digit)
 
bool is_invalid (const char_t c)
 
template<typename T >
bool is_ivariable_node (const expression_node< T > *node)
 
template<typename T >
bool is_ivector_node (const expression_node< T > *node)
 
bool is_left_bracket (const char_t c)
 
bool is_letter (const char_t c)
 
bool is_letter_or_digit (const char_t c)
 
bool is_logic_opr (const std::string &lgc_opr)
 
template<typename T >
bool is_neg_unary_node (const expression_node< T > *node)
 
template<typename T >
bool is_negate_node (const expression_node< T > *node)
 
template<typename T >
bool is_null_node (const expression_node< T > *node)
 
bool is_operator_char (const char_t c)
 
template<typename T >
bool is_rebasevector_celem_node (const expression_node< T > *node)
 
template<typename T >
bool is_rebasevector_elem_node (const expression_node< T > *node)
 
bool is_reserved_symbol (const std::string &symbol)
 
bool is_reserved_word (const std::string &symbol)
 
template<typename T >
bool is_return_node (const expression_node< T > *node)
 
bool is_right_bracket (const char_t c)
 
template<typename T >
bool is_sf3ext_node (const expression_node< T > *n)
 
template<typename T >
bool is_sf4ext_node (const expression_node< T > *n)
 
bool is_sign (const char_t c)
 
template<typename T >
bool is_string_assignment_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_concat_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_function_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_string_vararg_node (const expression_node< T > *node)
 
template<typename T >
bool is_swap_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)
 
bool is_true (const double v)
 
template<typename T >
bool is_true (const expression_node< T > *node)
 
bool is_true (const float v)
 
bool is_true (const long double v)
 
template<typename T >
bool is_true (const std::complex< T > &v)
 
template<typename T >
bool is_true (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_uv_node (const expression_node< T > *node)
 
bool is_valid_sf_symbol (const std::string &symbol)
 
bool is_valid_string_char (const char_t c)
 
template<typename T >
bool is_variable_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_node (const expression_node< T > *node)
 
template<typename T >
bool is_voc_node (const expression_node< T > *node)
 
template<typename T >
bool is_vov_node (const expression_node< T > *node)
 
bool is_whitespace (const char_t c)
 
void load_operations_map (std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)
 
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)
 
template<typename Iterator >
bool parse_hex (Iterator &itr, Iterator end, std::string::value_type &result)
 
bool sequence_match (const std::string &pattern, const std::string &str, std::size_t &diff_index, char_t &diff_value)
 
template<typename T >
bool string_to_real (const std::string &s, T &t)
 
template<typename Iterator , typename T >
bool string_to_real (Iterator &itr_external, const Iterator end, T &t, numeric::details::real_type_tag)
 
template<typename Iterator , typename T >
bool string_to_type_converter_impl_ref (Iterator &itr, const Iterator end, T &result)
 
 synthesis_node_type_define (const T0 &, const T1 &, const T2 &, const T3 &, e_vovovov) synthesis_node_type_define(const T0 &
 
 synthesis_node_type_define (const T0 &, const T1 &, const T2 &, e_vovov) 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 &
 
 synthesis_node_type_define (const T0 &, const T1 &, e_vov) 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 e_vovoc synthesis_node_type_define (const T0 &, const T1, const T2 &, e_vocov) 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 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 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 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 e_voc synthesis_node_type_define (const T0, const T1 &, e_cov) synthesis_node_type_define(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 &
 
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 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 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
 
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
 
x y t t *t x y t t t x 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 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 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 t (t/t)") define_sfop3(19
 
std::string to_str (const operator_type opr)
 
std::string to_str (int i)
 
std::string to_str (std::size_t i)
 
template<typename T >
bool valid_exponent (const int exponent, numeric::details::real_type_tag)
 
template<typename T >
T value (const T &t)
 
template<typename T >
T value (const T *t)
 
template<typename T >
T value (details::expression_node< T > *n)
 
template<typename T >
T value (std::pair< details::expression_node< T > *, bool > n)
 
bool wc_imatch (const std::string &wild_card, const std::string &str)
 
bool wc_match (const std::string &wild_card, const std::string &str)
 
x y t t *t x y t t t x y t 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 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+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/z)
 

Variables

const e_voc T1 e_none const e_none T1 e_none T0
 
const T1
 
const T1 const T2
 
const T1 const T2 const T3
 
x y * z
 

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 > *(&) b[N])
inline

◆ all_nodes_variables() [1/2]

template<std::size_t N, typename T >
bool exprtk::details::all_nodes_variables ( expression_node< T > *(&) b[N])
inline

◆ 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

◆ axn()

template<typename T , std::size_t N>
T exprtk::details::axn ( T a,
T x )
inline

◆ axnb()

template<typename T , std::size_t N>
T exprtk::details::axnb ( T a,
T x,
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 ( expression_node< T > * node)
inline

◆ case_normalise()

void exprtk::details::case_normalise ( std::string & s)
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

◆ 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 std::string::value_type 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_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_elem_node()

template<typename T >
bool exprtk::details::is_rebasevector_elem_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/6]

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

◆ is_true() [2/6]

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

◆ 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

◆ 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_elem_node()

template<typename T >
bool exprtk::details::is_vector_elem_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

◆ 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

◆ parse_hex()

template<typename Iterator >
bool exprtk::details::parse_hex ( Iterator & itr,
Iterator end,
std::string::value_type & result )
inline

◆ 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

◆ 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

◆ 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