- Generated on Sat Jan 28 2017 10:55:03 for pelib by
1.7.6.1
|
pelib
2.0.0
|
#include <algorithm>#include <cctype>#include <cmath>#include <cstdio>#include <cstdlib>#include <deque>#include <exception>#include <iterator>#include <limits>#include <list>#include <map>#include <set>#include <stack>#include <stdexcept>#include <string>#include <utility>#include <vector>#include <ctime>#include <sys/time.h>#include <sys/types.h>Go to the source code of this file.
Namespaces | |
| namespace | exprtk |
Defines | |
| #define | exprtk_debug(params) (void)0 |
| #define | exprtk_register_real_type_tag(T) template<> struct number_type<T> { typedef real_type_tag type; }; \ |
| #define | exprtk_register_int_type_tag(T) template<> struct number_type<T> { typedef int_type_tag type; }; \ |
| #define | exprtk_define_unary_function(FunctionName) |
| #define | exprtk_process_digit if ((digit = (*itr++ - '0')) < 10) result = result * 10 + (digit); else { return_result = false; break; } |
| #define | parse_digit_1(d) if ((digit = (*itr - '0')) < 10) { d = d * T(10) + digit; } else break; if (end == ++itr) break; \ |
| #define | parse_digit_2(d) if ((digit = (*itr - '0')) < 10) { d = d * T(10) + digit; } else break; ++itr; \ |
| #define | define_sfop3(NN, OP0, OP1) |
| #define | define_sfop4(NN, OP0, OP1) |
| #define | exprtk_define_unary_op(OpName) |
| #define | synthesis_node_type_define(T0_, T1_, v_) |
| #define | synthesis_node_type_define(T0_, T1_, T2_, v_) |
| #define | synthesis_node_type_define(T0_, T1_, T2_, T3_, v_) |
| #define | register_op(Symbol, Type, Args) m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \ |
| #define | base_opr_case(N) |
| #define | register_synthezier(S) synthesize_map_[S ::node_type::id()] = S ::process; \ |
| #define | unary_opr_switch_statements |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | vector_ops |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | basic_opr_switch_statements |
| #define | extended_opr_switch_statements |
| #define | case_stmt(cp) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | string_opr_switch_statements |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | case_stmt(op0, op1) |
| #define | register_unary_op(Op, UnaryFunctor) m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \ |
| #define | register_binary_op(Op, BinaryFunctor) m.insert(typename binary_op_map_t::value_type(Op,BinaryFunctor<T>::process)); \ |
| #define | register_binary_op(Op, BinaryFunctor) m.insert(typename inv_binary_op_map_t::value_type(BinaryFunctor<T>::process,Op)); \ |
| #define | register_sf3(Op) sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \ |
| #define | register_sf4(Op) sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \ |
| #define | register_sf4ext(Op) sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \ |
Functions | |
| template<typename T > | |
| T | exprtk::integrate (expression< T > &e, T &x, const T &r0, const T &r1, const std::size_t number_of_intervals=1000000) |
| template<typename T > | |
| T | exprtk::integrate (expression< T > &e, const std::string &variable_name, const T &r0, const T &r1, const std::size_t number_of_intervals=1000000) |
| template<typename T > | |
| T | exprtk::derivative (expression< T > &e, T &x, const T &h=T(0.00000001)) |
| template<typename T > | |
| T | exprtk::second_derivative (expression< T > &e, T &x, const T &h=T(0.00001)) |
| template<typename T > | |
| T | exprtk::third_derivative (expression< T > &e, T &x, const T &h=T(0.0001)) |
| template<typename T > | |
| T | exprtk::derivative (expression< T > &e, const std::string &variable_name, const T &h=T(0.00000001)) |
| template<typename T > | |
| T | exprtk::second_derivative (expression< T > &e, const std::string &variable_name, const T &h=T(0.00001)) |
| template<typename T > | |
| T | exprtk::third_derivative (expression< T > &e, const std::string &variable_name, const T &h=T(0.0001)) |
| template<typename T > | |
| bool | exprtk::compute (const std::string &expression_string, T &result) |
| template<typename T > | |
| bool | exprtk::compute (const std::string &expression_string, const T &x, T &result) |
| template<typename T > | |
| bool | exprtk::compute (const std::string &expression_string, const T &x, const T &y, T &result) |
| template<typename T > | |
| bool | exprtk::compute (const std::string &expression_string, const T &x, const T &y, const T &z, T &result) |
| template<typename T > | |
| bool | exprtk::pgo_primer () |
| #define base_opr_case | ( | N | ) |
case N : { \
expression_node_ptr pl##N[N] = {0}; \
std::copy(param_list,param_list + N,pl##N); \
return expression_generator_(operation.type,pl##N); \
} \
| #define basic_opr_switch_statements |
case_stmt(details::e_add,details::add_op) \ case_stmt(details::e_sub,details::sub_op) \ case_stmt(details::e_mul,details::mul_op) \ case_stmt(details::e_div,details::div_op) \ case_stmt(details::e_mod,details::mod_op) \ case_stmt(details::e_pow,details::pow_op) \
Definition at line 19339 of file exprtk.hpp.
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<typename details::unary_variable_node<Type,op1<Type> > >(v); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<typename details::unary_vector_node<Type,op1<Type> > > \ (operation,branch[0]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<typename details::unary_branch_node<Type,op1<Type> > >(branch[0]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : temp_node = node_allocator_-> \
allocate<details::sf3_node<Type,op1<Type> > > \
(operation,branch); \
break; \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate_rrr<details::sf3_var_node<Type,op1<Type> > > \ (v0,v1,v2); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<details::sf3_node<Type,op1<Type> > >(operation,branch); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : temp_node = node_allocator_-> \
allocate<details::sf4_node<Type,op1<Type> > >(operation,branch); \
break; \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate_rrrr<details::sf4_var_node<Type,op1<Type> > >(v0,v1,v2,v3); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<details::sf4_node<Type,op1<Type> > >(operation,branch); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : temp_node = node_allocator_-> \
allocate<details::vararg_node<Type,op1<Type> > > \
(arg_list); \
break; \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<details::vectorize_node<Type,op1<Type> > >(arg_list[0]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate<details::vararg_node<Type,op1<Type> > >(arg_list); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::assignment_op_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::assignment_vec_elem_op_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::assignment_vecvec_op_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::assignment_vec_op_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::eqineq_vecvec_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::eqineq_vecval_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::eqineq_valvec_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::vecarith_vecvec_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::vecarith_vecval_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ template allocate_rrr<typename details::vecarith_valvec_node<Type,op1<Type> > > \ (operation,branch[0],branch[1]); \
| #define case_stmt | ( | cp | ) |
case cp : return node_allocator_-> \ allocate<IPowNode<T,details::numeric::fast_exp<T,cp> > >(v); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate<typename details::binary_ext_node<Type,op1<Type> > > \ (branch[0],branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_rc<typename details::vob_node<Type,op1<Type> > > \ (v,branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_cr<typename details::bov_node<Type,op1<Type> > > \ (branch[0],v); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_tt<typename details::cob_node<Type,op1<Type> > > \ (c,branch[1]); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_cr<typename details::boc_node<Type,op1<Type> > > \ (branch[0],c); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_rr<typename details::vov_node<Type,op1<Type> > > \ (v1,v2); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_cr<typename details::cov_node<Type,op1<Type> > > \ (c,v); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return expr_gen.node_allocator_-> \ template allocate_rc<typename details::voc_node<Type,op1<Type> > > \ (v,c); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,op1<Type> >:: \ allocate(*(expr_gen.node_allocator_),t0,t1,t2); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,op1<Type> >:: \ allocate(*(expr_gen.node_allocator_),t0,t1,t2,t3); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_pack,op1<Type> >,T0,T1> \ (s0,s1,rp0); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_pack,op1<Type> >,T0,T1> \ (s0,s1,rp1); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_pack,op1<Type> >,T0,T1> \ (s0,s1,rp0,rp1); \
| #define case_stmt | ( | op0, | |
| op1 | |||
| ) |
case op0 : return node_allocator_-> \ allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0,s1); \
| #define define_sfop3 | ( | NN, | |
| OP0, | |||
| OP1 | |||
| ) |
template <typename T> \ struct sf##NN##_op : public sf_base<T> \ { \ typedef typename sf_base<T>::Type Type; \ static inline T process(Type x, Type y, Type z) \ { \ return (OP0); \ } \ static inline std::string id() \ { \ return OP1; \ } \ }; \
Definition at line 5942 of file exprtk.hpp.
| #define define_sfop4 | ( | NN, | |
| OP0, | |||
| OP1 | |||
| ) |
template <typename T> \ struct sf##NN##_op : public sf_base<T> \ { \ typedef typename sf_base<T>::Type Type; \ static inline T process(Type x, Type y, Type z, Type w) \ { \ return (OP0); \ } \ static inline std::string id() { return OP1; } \ }; \
| #define exprtk_debug | ( | params | ) | (void)0 |
Definition at line 61 of file exprtk.hpp.
| #define exprtk_define_unary_function | ( | FunctionName | ) |
template <typename T> \ inline T FunctionName (const T v) \ { \ typename details::number_type<T>::type num_type; \ return FunctionName##_impl(v,num_type); \ } \
Definition at line 1191 of file exprtk.hpp.
| #define exprtk_define_unary_op | ( | OpName | ) |
template <typename T> \ struct OpName##_op \ { \ typedef typename functor_t<T>::Type Type; \ static inline T process(Type v) { return numeric:: OpName (v); } \ static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_##OpName; } \ static inline details::operator_type operation() { return details::e_##OpName; } \ }; \
Definition at line 7932 of file exprtk.hpp.
| #define exprtk_process_digit if ((digit = (*itr++ - '0')) < 10) result = result * 10 + (digit); else { return_result = false; break; } |
| #define exprtk_register_int_type_tag | ( | T | ) | template<> struct number_type<T> { typedef int_type_tag type; }; \ |
Definition at line 440 of file exprtk.hpp.
| #define exprtk_register_real_type_tag | ( | T | ) | template<> struct number_type<T> { typedef real_type_tag type; }; \ |
Definition at line 437 of file exprtk.hpp.
| #define extended_opr_switch_statements |
case_stmt(details:: e_lt,details:: lt_op) \ case_stmt(details:: e_lte,details:: lte_op) \ case_stmt(details:: e_gt,details:: gt_op) \ case_stmt(details:: e_gte,details:: gte_op) \ case_stmt(details:: e_eq,details:: eq_op) \ case_stmt(details:: e_ne,details:: ne_op) \ case_stmt(details:: e_and,details:: and_op) \ case_stmt(details::e_nand,details::nand_op) \ case_stmt(details:: e_or,details:: or_op) \ case_stmt(details:: e_nor,details:: nor_op) \ case_stmt(details:: e_xor,details:: xor_op) \ case_stmt(details::e_xnor,details::xnor_op) \
Definition at line 19347 of file exprtk.hpp.
| #define parse_digit_1 | ( | d | ) | if ((digit = (*itr - '0')) < 10) { d = d * T(10) + digit; } else break; if (end == ++itr) break; \ |
| #define parse_digit_2 | ( | d | ) | if ((digit = (*itr - '0')) < 10) { d = d * T(10) + digit; } else break; ++itr; \ |
| #define register_binary_op | ( | Op, | |
| BinaryFunctor | |||
| ) | m.insert(typename binary_op_map_t::value_type(Op,BinaryFunctor<T>::process)); \ |
| #define register_binary_op | ( | Op, | |
| BinaryFunctor | |||
| ) | m.insert(typename inv_binary_op_map_t::value_type(BinaryFunctor<T>::process,Op)); \ |
| #define register_op | ( | Symbol, | |
| Type, | |||
| Args | |||
| ) | m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \ |
| #define register_sf3 | ( | Op | ) | sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \ |
| #define register_sf4 | ( | Op | ) | sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \ |
| #define register_sf4ext | ( | Op | ) | sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \ |
| #define register_synthezier | ( | S | ) | synthesize_map_[S ::node_type::id()] = S ::process; \ |
| #define register_unary_op | ( | Op, | |
| UnaryFunctor | |||
| ) | m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \ |
| #define string_opr_switch_statements |
case_stmt(details:: e_lt ,details:: lt_op) \ case_stmt(details:: e_lte ,details:: lte_op) \ case_stmt(details:: e_gt ,details:: gt_op) \ case_stmt(details:: e_gte ,details:: gte_op) \ case_stmt(details:: e_eq ,details:: eq_op) \ case_stmt(details:: e_ne ,details:: ne_op) \ case_stmt(details::e_in ,details:: in_op) \ case_stmt(details::e_like ,details:: like_op) \ case_stmt(details::e_ilike,details::ilike_op) \
Definition at line 24522 of file exprtk.hpp.
| #define synthesis_node_type_define | ( | T0_, | |
| T1_, | |||
| v_ | |||
| ) |
template <typename T, typename T0, typename T1> \ struct nodetype_T0oT1<T,T0_,T1_> { static const typename expression_node<T>::node_type result; }; \ template <typename T, typename T0, typename T1> \ const typename expression_node<T>::node_type nodetype_T0oT1<T,T0_,T1_>::result = expression_node<T>:: v_; \
Definition at line 9451 of file exprtk.hpp.
| #define synthesis_node_type_define | ( | T0_, | |
| T1_, | |||
| T2_, | |||
| v_ | |||
| ) |
template <typename T, typename T0, typename T1, typename T2> \ struct nodetype_T0oT1oT2<T,T0_,T1_,T2_> { static const typename expression_node<T>::node_type result; }; \ template <typename T, typename T0, typename T1, typename T2> \ const typename expression_node<T>::node_type nodetype_T0oT1oT2<T,T0_,T1_,T2_>::result = expression_node<T>:: v_; \
Definition at line 9451 of file exprtk.hpp.
| #define synthesis_node_type_define | ( | T0_, | |
| T1_, | |||
| T2_, | |||
| T3_, | |||
| v_ | |||
| ) |
template <typename T, typename T0, typename T1, typename T2, typename T3> \ struct nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_> { static const typename expression_node<T>::node_type result; }; \ template <typename T, typename T0, typename T1, typename T2, typename T3> \ const typename expression_node<T>::node_type nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_>::result = expression_node<T>:: v_; \
Definition at line 9451 of file exprtk.hpp.
| #define unary_opr_switch_statements |
Definition at line 18388 of file exprtk.hpp.
| #define vector_ops |
case_stmt(details::e_add,details::add_op) \ case_stmt(details::e_sub,details::sub_op) \ case_stmt(details::e_mul,details::mul_op) \ case_stmt(details::e_div,details::div_op) \ case_stmt(details::e_mod,details::mod_op) \
1.7.6.1