exprtk.hpp File Reference

#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#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>
#include <fstream>

Include dependency graph for exprtk.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	exprtk::details::ilesscompare
class	exprtk::details::build_string
struct	exprtk::details::cs_match
struct	exprtk::details::cis_match
struct	exprtk::details::set_zero_value_impl< T >
struct	exprtk::details::set_zero_value_impl< float >
struct	exprtk::details::set_zero_value_impl< double >
struct	exprtk::details::set_zero_value_impl< long double >
struct	exprtk::details::numeric::details::unknown_type_tag
struct	exprtk::details::numeric::details::real_type_tag
struct	exprtk::details::numeric::details::int_type_tag
struct	exprtk::details::numeric::details::number_type< T >
struct	exprtk::details::numeric::details::number_type< float >
struct	exprtk::details::numeric::details::number_type< double >
struct	exprtk::details::numeric::details::number_type< long double >
struct	exprtk::details::numeric::details::number_type< short >
struct	exprtk::details::numeric::details::number_type< int >
struct	exprtk::details::numeric::details::number_type< _int64_t >
struct	exprtk::details::numeric::details::number_type< unsigned short >
struct	exprtk::details::numeric::details::number_type< unsigned int >
struct	exprtk::details::numeric::details::number_type< _uint64_t >
struct	exprtk::details::numeric::details::epsilon_type< T >
struct	exprtk::details::numeric::details::epsilon_type< float >
struct	exprtk::details::numeric::details::epsilon_type< double >
struct	exprtk::details::numeric::details::epsilon_type< long double >
struct	exprtk::details::numeric::numeric_info< Type >
struct	exprtk::details::numeric::numeric_info< int >
struct	exprtk::details::numeric::numeric_info< float >
struct	exprtk::details::numeric::numeric_info< double >
struct	exprtk::details::numeric::numeric_info< long double >
struct	exprtk::details::numeric::fast_exp< T, N >
struct	exprtk::details::numeric::fast_exp< T, 10 >
struct	exprtk::details::numeric::fast_exp< T, 9 >
struct	exprtk::details::numeric::fast_exp< T, 8 >
struct	exprtk::details::numeric::fast_exp< T, 7 >
struct	exprtk::details::numeric::fast_exp< T, 6 >
struct	exprtk::details::numeric::fast_exp< T, 5 >
struct	exprtk::details::numeric::fast_exp< T, 4 >
struct	exprtk::details::numeric::fast_exp< T, 3 >
struct	exprtk::details::numeric::fast_exp< T, 2 >
struct	exprtk::details::numeric::fast_exp< T, 1 >
struct	exprtk::details::numeric::fast_exp< T, 0 >
struct	exprtk::details::functor_t< T >
struct	exprtk::loop_runtime_check
struct	exprtk::loop_runtime_check::violation_context
struct	exprtk::vector_access_runtime_check
struct	exprtk::vector_access_runtime_check::violation_context
struct	exprtk::compilation_check
struct	exprtk::compilation_check::compilation_context
struct	exprtk::lexer::token
class	exprtk::lexer::generator
class	exprtk::lexer::helper_interface
class	exprtk::lexer::token_scanner
class	exprtk::lexer::token_modifier
class	exprtk::lexer::token_inserter
class	exprtk::lexer::token_joiner
class	exprtk::lexer::helper::commutative_inserter
class	exprtk::lexer::helper::operator_joiner
class	exprtk::lexer::helper::bracket_checker
class	exprtk::lexer::helper::numeric_checker< T >
class	exprtk::lexer::helper::symbol_replacer
class	exprtk::lexer::helper::sequence_validator
class	exprtk::lexer::helper::sequence_validator_3tokens
struct	exprtk::lexer::helper::helper_assembly
class	exprtk::lexer::parser_helper
class	exprtk::vector_view< T >
struct	exprtk::type_store< T >
class	exprtk::type_store< T >::parameter_list
struct	exprtk::type_store< T >::type_view< ViewType >
struct	exprtk::type_store< T >::scalar_view
class	exprtk::results_context< T >
struct	exprtk::details::base_operation_t
struct	exprtk::details::loop_unroll::details
class	exprtk::details::vec_data_store< T >
struct	exprtk::details::vec_data_store< T >::control_block
struct	exprtk::details::node_collector_interface< Node >
class	exprtk::details::expression_node< T >
class	exprtk::details::node_collection_destructor< Node >
struct	exprtk::details::node_depth_base< Node >
class	exprtk::details::vector_holder< Type >
class	exprtk::details::vector_holder< Type >::vector_holder_base
class	exprtk::details::vector_holder< Type >::array_vector_impl
class	exprtk::details::vector_holder< Type >::sequence_vector_impl< Allocator, Sequence >
class	exprtk::details::vector_holder< Type >::vector_view_impl
class	exprtk::details::vector_holder< Type >::resizable_vector_impl
class	exprtk::details::null_node< T >
class	exprtk::details::null_eq_node< T >
class	exprtk::details::literal_node< T >
class	exprtk::details::range_interface< T >
class	exprtk::details::string_base_node< T >
class	exprtk::details::string_literal_node< T >
class	exprtk::details::unary_node< T >
class	exprtk::details::binary_node< T >
class	exprtk::details::binary_ext_node< T, Operation >
class	exprtk::details::trinary_node< T >
class	exprtk::details::quaternary_node< T >
class	exprtk::details::conditional_node< T >
class	exprtk::details::cons_conditional_node< T >
class	exprtk::details::break_exception< T >
class	exprtk::details::continue_exception
class	exprtk::details::break_node< T >
class	exprtk::details::continue_node< T >
struct	exprtk::details::loop_runtime_checker
class	exprtk::details::while_loop_node< T >
class	exprtk::details::while_loop_rtc_node< T >
class	exprtk::details::repeat_until_loop_node< T >
class	exprtk::details::repeat_until_loop_rtc_node< T >
class	exprtk::details::for_loop_node< T >
class	exprtk::details::for_loop_rtc_node< T >
class	exprtk::details::while_loop_bc_node< T >
class	exprtk::details::while_loop_bc_rtc_node< T >
class	exprtk::details::repeat_until_loop_bc_node< T >
class	exprtk::details::repeat_until_loop_bc_rtc_node< T >
class	exprtk::details::for_loop_bc_node< T >
class	exprtk::details::for_loop_bc_rtc_node< T >
class	exprtk::details::switch_node< T >
class	exprtk::details::switch_n_node< T, Switch_N >
class	exprtk::details::multi_switch_node< T >
class	exprtk::details::ivariable< T >
class	exprtk::details::variable_node< T >
struct	exprtk::details::range_pack< T >
struct	exprtk::details::range_data_type< T >
class	exprtk::details::vector_interface< T >
class	exprtk::details::vector_node< T >
class	exprtk::details::vector_size_node< T >
class	exprtk::details::vector_elem_node< T >
class	exprtk::details::vector_celem_node< T >
class	exprtk::details::vector_elem_rtc_node< T >
class	exprtk::details::vector_celem_rtc_node< T >
class	exprtk::details::rebasevector_elem_node< T >
class	exprtk::details::rebasevector_celem_node< T >
class	exprtk::details::rebasevector_elem_rtc_node< T >
class	exprtk::details::rebasevector_celem_rtc_node< T >
class	exprtk::details::vector_assignment_node< T >
class	exprtk::details::swap_node< T >
class	exprtk::details::swap_generic_node< T >
class	exprtk::details::swap_vecvec_node< T >
class	exprtk::details::stringvar_node< T >
class	exprtk::details::string_range_node< T >
class	exprtk::details::const_string_range_node< T >
class	exprtk::details::generic_string_range_node< T >
class	exprtk::details::string_concat_node< T >
class	exprtk::details::swap_string_node< T >
class	exprtk::details::swap_genstrings_node< T >
class	exprtk::details::stringvar_size_node< T >
class	exprtk::details::string_size_node< T >
struct	exprtk::details::asn_assignment
struct	exprtk::details::asn_addassignment
class	exprtk::details::assignment_string_node< T, AssignmentProcess >
class	exprtk::details::assignment_string_range_node< T, AssignmentProcess >
class	exprtk::details::conditional_string_node< T >
class	exprtk::details::cons_conditional_str_node< T >
class	exprtk::details::str_vararg_node< T, VarArgFunction >
struct	exprtk::details::sf_base< T >
struct	exprtk::details::sf00_op< T >
struct	exprtk::details::sf01_op< T >
struct	exprtk::details::sf02_op< T >
struct	exprtk::details::sf03_op< T >
struct	exprtk::details::sf04_op< T >
struct	exprtk::details::sf05_op< T >
struct	exprtk::details::sf06_op< T >
struct	exprtk::details::sf07_op< T >
struct	exprtk::details::sf08_op< T >
struct	exprtk::details::sf09_op< T >
struct	exprtk::details::sf10_op< T >
struct	exprtk::details::sf11_op< T >
struct	exprtk::details::sf12_op< T >
struct	exprtk::details::sf13_op< T >
struct	exprtk::details::sf14_op< T >
struct	exprtk::details::sf15_op< T >
struct	exprtk::details::sf16_op< T >
struct	exprtk::details::sf17_op< T >
struct	exprtk::details::sf18_op< T >
struct	exprtk::details::sf19_op< T >
struct	exprtk::details::sf20_op< T >
struct	exprtk::details::sf21_op< T >
struct	exprtk::details::sf22_op< T >
struct	exprtk::details::sf23_op< T >
struct	exprtk::details::sf24_op< T >
struct	exprtk::details::sf25_op< T >
struct	exprtk::details::sf26_op< T >
struct	exprtk::details::sf27_op< T >
struct	exprtk::details::sf28_op< T >
struct	exprtk::details::sf29_op< T >
struct	exprtk::details::sf30_op< T >
struct	exprtk::details::sf31_op< T >
struct	exprtk::details::sf32_op< T >
struct	exprtk::details::sf33_op< T >
struct	exprtk::details::sf34_op< T >
struct	exprtk::details::sf35_op< T >
struct	exprtk::details::sf36_op< T >
struct	exprtk::details::sf37_op< T >
struct	exprtk::details::sf38_op< T >
struct	exprtk::details::sf39_op< T >
struct	exprtk::details::sf40_op< T >
struct	exprtk::details::sf41_op< T >
struct	exprtk::details::sf42_op< T >
struct	exprtk::details::sf43_op< T >
struct	exprtk::details::sf44_op< T >
struct	exprtk::details::sf45_op< T >
struct	exprtk::details::sf46_op< T >
struct	exprtk::details::sf47_op< T >
struct	exprtk::details::sf48_op< T >
struct	exprtk::details::sf49_op< T >
struct	exprtk::details::sf50_op< T >
struct	exprtk::details::sf51_op< T >
struct	exprtk::details::sf52_op< T >
struct	exprtk::details::sf53_op< T >
struct	exprtk::details::sf54_op< T >
struct	exprtk::details::sf55_op< T >
struct	exprtk::details::sf56_op< T >
struct	exprtk::details::sf57_op< T >
struct	exprtk::details::sf58_op< T >
struct	exprtk::details::sf59_op< T >
struct	exprtk::details::sf60_op< T >
struct	exprtk::details::sf61_op< T >
struct	exprtk::details::sf62_op< T >
struct	exprtk::details::sf63_op< T >
struct	exprtk::details::sf64_op< T >
struct	exprtk::details::sf65_op< T >
struct	exprtk::details::sf66_op< T >
struct	exprtk::details::sf67_op< T >
struct	exprtk::details::sf68_op< T >
struct	exprtk::details::sf69_op< T >
struct	exprtk::details::sf70_op< T >
struct	exprtk::details::sf71_op< T >
struct	exprtk::details::sf72_op< T >
struct	exprtk::details::sf73_op< T >
struct	exprtk::details::sf74_op< T >
struct	exprtk::details::sf75_op< T >
struct	exprtk::details::sf76_op< T >
struct	exprtk::details::sf77_op< T >
struct	exprtk::details::sf78_op< T >
struct	exprtk::details::sf79_op< T >
struct	exprtk::details::sf80_op< T >
struct	exprtk::details::sf81_op< T >
struct	exprtk::details::sf82_op< T >
struct	exprtk::details::sf83_op< T >
struct	exprtk::details::sf84_op< T >
struct	exprtk::details::sf85_op< T >
struct	exprtk::details::sf86_op< T >
struct	exprtk::details::sf87_op< T >
struct	exprtk::details::sf88_op< T >
struct	exprtk::details::sf89_op< T >
struct	exprtk::details::sf90_op< T >
struct	exprtk::details::sf91_op< T >
struct	exprtk::details::sf92_op< T >
struct	exprtk::details::sf93_op< T >
struct	exprtk::details::sf94_op< T >
struct	exprtk::details::sf95_op< T >
struct	exprtk::details::sf96_op< T >
struct	exprtk::details::sf97_op< T >
struct	exprtk::details::sf98_op< T >
struct	exprtk::details::sf99_op< T >
struct	exprtk::details::sfext00_op< T >
struct	exprtk::details::sfext01_op< T >
struct	exprtk::details::sfext02_op< T >
struct	exprtk::details::sfext03_op< T >
struct	exprtk::details::sfext04_op< T >
struct	exprtk::details::sfext05_op< T >
struct	exprtk::details::sfext06_op< T >
struct	exprtk::details::sfext07_op< T >
struct	exprtk::details::sfext08_op< T >
struct	exprtk::details::sfext09_op< T >
struct	exprtk::details::sfext10_op< T >
struct	exprtk::details::sfext11_op< T >
struct	exprtk::details::sfext12_op< T >
struct	exprtk::details::sfext13_op< T >
struct	exprtk::details::sfext14_op< T >
struct	exprtk::details::sfext15_op< T >
struct	exprtk::details::sfext16_op< T >
struct	exprtk::details::sfext17_op< T >
struct	exprtk::details::sfext18_op< T >
struct	exprtk::details::sfext19_op< T >
struct	exprtk::details::sfext20_op< T >
struct	exprtk::details::sfext21_op< T >
struct	exprtk::details::sfext22_op< T >
struct	exprtk::details::sfext23_op< T >
struct	exprtk::details::sfext24_op< T >
struct	exprtk::details::sfext25_op< T >
struct	exprtk::details::sfext26_op< T >
struct	exprtk::details::sfext27_op< T >
struct	exprtk::details::sfext28_op< T >
struct	exprtk::details::sfext29_op< T >
struct	exprtk::details::sfext30_op< T >
struct	exprtk::details::sfext31_op< T >
struct	exprtk::details::sfext32_op< T >
struct	exprtk::details::sfext33_op< T >
struct	exprtk::details::sfext34_op< T >
struct	exprtk::details::sfext35_op< T >
struct	exprtk::details::sfext36_op< T >
struct	exprtk::details::sfext37_op< T >
struct	exprtk::details::sfext38_op< T >
struct	exprtk::details::sfext39_op< T >
struct	exprtk::details::sfext40_op< T >
struct	exprtk::details::sfext41_op< T >
struct	exprtk::details::sfext42_op< T >
struct	exprtk::details::sfext43_op< T >
struct	exprtk::details::sfext44_op< T >
struct	exprtk::details::sfext45_op< T >
struct	exprtk::details::sfext46_op< T >
struct	exprtk::details::sfext47_op< T >
struct	exprtk::details::sfext48_op< T >
struct	exprtk::details::sfext49_op< T >
struct	exprtk::details::sfext50_op< T >
struct	exprtk::details::sfext51_op< T >
struct	exprtk::details::sfext52_op< T >
struct	exprtk::details::sfext53_op< T >
struct	exprtk::details::sfext54_op< T >
struct	exprtk::details::sfext55_op< T >
struct	exprtk::details::sfext56_op< T >
struct	exprtk::details::sfext57_op< T >
struct	exprtk::details::sfext58_op< T >
struct	exprtk::details::sfext59_op< T >
struct	exprtk::details::sfext60_op< T >
struct	exprtk::details::sfext61_op< T >
class	exprtk::details::sf3_node< T, SpecialFunction >
class	exprtk::details::sf4_node< T, SpecialFunction >
class	exprtk::details::sf3_var_node< T, SpecialFunction >
class	exprtk::details::sf4_var_node< T, SpecialFunction >
class	exprtk::details::vararg_node< T, VarArgFunction >
class	exprtk::details::vararg_varnode< T, VarArgFunction >
class	exprtk::details::vectorize_node< T, VecFunction >
class	exprtk::details::assignment_node< T >
class	exprtk::details::assignment_vec_elem_node< T >
class	exprtk::details::assignment_vec_elem_rtc_node< T >
class	exprtk::details::assignment_rebasevec_elem_node< T >
class	exprtk::details::assignment_rebasevec_elem_rtc_node< T >
class	exprtk::details::assignment_rebasevec_celem_node< T >
class	exprtk::details::assignment_vec_node< T >
class	exprtk::details::assignment_vecvec_node< T >
class	exprtk::details::assignment_op_node< T, Operation >
class	exprtk::details::assignment_vec_elem_op_node< T, Operation >
class	exprtk::details::assignment_vec_elem_op_rtc_node< T, Operation >
class	exprtk::details::assignment_vec_celem_op_rtc_node< T, Operation >
class	exprtk::details::assignment_rebasevec_elem_op_node< T, Operation >
class	exprtk::details::assignment_rebasevec_celem_op_node< T, Operation >
class	exprtk::details::assignment_rebasevec_elem_op_rtc_node< T, Operation >
class	exprtk::details::assignment_rebasevec_celem_op_rtc_node< T, Operation >
class	exprtk::details::assignment_vec_op_node< T, Operation >
class	exprtk::details::assignment_vecvec_op_node< T, Operation >
struct	exprtk::details::memory_context_t< T >
class	exprtk::details::vec_binop_vecvec_node< T, Operation >
class	exprtk::details::vec_binop_vecval_node< T, Operation >
class	exprtk::details::vec_binop_valvec_node< T, Operation >
class	exprtk::details::unary_vector_node< T, Operation >
class	exprtk::details::conditional_vector_node< T >
class	exprtk::details::scand_node< T >
class	exprtk::details::scor_node< T >
class	exprtk::details::function_N_node< T, IFunction, N >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, BranchCount >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 6 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 5 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 4 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 3 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 2 >
struct	exprtk::details::function_N_node< T, IFunction, N >::evaluate_branches< T_, 1 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, ParamCount >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 20 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 19 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 18 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 17 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 16 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 15 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 14 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 13 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 12 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 11 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 10 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 9 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 8 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 7 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 6 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 5 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 4 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 3 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 2 >
struct	exprtk::details::function_N_node< T, IFunction, N >::invoke< T_, 1 >
class	exprtk::details::function_N_node< T, IFunction, 0 >
class	exprtk::details::vararg_function_node< T, VarArgFunction >
class	exprtk::details::generic_function_node< T, GenericFunction >
class	exprtk::details::string_function_node< T, StringFunction >
class	exprtk::details::multimode_genfunction_node< T, GenericFunction >
class	exprtk::details::multimode_strfunction_node< T, StringFunction >
class	exprtk::details::return_exception
class	exprtk::details::null_igenfunc< T >
class	exprtk::details::return_node< T >
class	exprtk::details::return_envelope_node< T >
struct	exprtk::details::abs_op< T >
struct	exprtk::details::acos_op< T >
struct	exprtk::details::acosh_op< T >
struct	exprtk::details::asin_op< T >
struct	exprtk::details::asinh_op< T >
struct	exprtk::details::atan_op< T >
struct	exprtk::details::atanh_op< T >
struct	exprtk::details::ceil_op< T >
struct	exprtk::details::cos_op< T >
struct	exprtk::details::cosh_op< T >
struct	exprtk::details::cot_op< T >
struct	exprtk::details::csc_op< T >
struct	exprtk::details::d2g_op< T >
struct	exprtk::details::d2r_op< T >
struct	exprtk::details::erf_op< T >
struct	exprtk::details::erfc_op< T >
struct	exprtk::details::exp_op< T >
struct	exprtk::details::expm1_op< T >
struct	exprtk::details::floor_op< T >
struct	exprtk::details::frac_op< T >
struct	exprtk::details::g2d_op< T >
struct	exprtk::details::log_op< T >
struct	exprtk::details::log10_op< T >
struct	exprtk::details::log2_op< T >
struct	exprtk::details::log1p_op< T >
struct	exprtk::details::ncdf_op< T >
struct	exprtk::details::neg_op< T >
struct	exprtk::details::notl_op< T >
struct	exprtk::details::pos_op< T >
struct	exprtk::details::r2d_op< T >
struct	exprtk::details::round_op< T >
struct	exprtk::details::sec_op< T >
struct	exprtk::details::sgn_op< T >
struct	exprtk::details::sin_op< T >
struct	exprtk::details::sinc_op< T >
struct	exprtk::details::sinh_op< T >
struct	exprtk::details::sqrt_op< T >
struct	exprtk::details::tan_op< T >
struct	exprtk::details::tanh_op< T >
struct	exprtk::details::trunc_op< T >
struct	exprtk::details::opr_base< T >
struct	exprtk::details::add_op< T >
struct	exprtk::details::mul_op< T >
struct	exprtk::details::sub_op< T >
struct	exprtk::details::div_op< T >
struct	exprtk::details::mod_op< T >
struct	exprtk::details::pow_op< T >
struct	exprtk::details::lt_op< T >
struct	exprtk::details::lte_op< T >
struct	exprtk::details::gt_op< T >
struct	exprtk::details::gte_op< T >
struct	exprtk::details::eq_op< T >
struct	exprtk::details::equal_op< T >
struct	exprtk::details::ne_op< T >
struct	exprtk::details::and_op< T >
struct	exprtk::details::nand_op< T >
struct	exprtk::details::or_op< T >
struct	exprtk::details::nor_op< T >
struct	exprtk::details::xor_op< T >
struct	exprtk::details::xnor_op< T >
struct	exprtk::details::in_op< T >
struct	exprtk::details::like_op< T >
struct	exprtk::details::ilike_op< T >
struct	exprtk::details::inrange_op< T >
struct	exprtk::details::vararg_add_op< T >
struct	exprtk::details::vararg_mul_op< T >
struct	exprtk::details::vararg_avg_op< T >
struct	exprtk::details::vararg_min_op< T >
struct	exprtk::details::vararg_max_op< T >
struct	exprtk::details::vararg_mand_op< T >
struct	exprtk::details::vararg_mor_op< T >
struct	exprtk::details::vararg_multi_op< T >
struct	exprtk::details::vec_add_op< T >
struct	exprtk::details::vec_mul_op< T >
struct	exprtk::details::vec_avg_op< T >
struct	exprtk::details::vec_min_op< T >
struct	exprtk::details::vec_max_op< T >
class	exprtk::details::vov_base_node< T >
class	exprtk::details::cov_base_node< T >
class	exprtk::details::voc_base_node< T >
class	exprtk::details::vob_base_node< T >
class	exprtk::details::bov_base_node< T >
class	exprtk::details::cob_base_node< T >
class	exprtk::details::boc_base_node< T >
class	exprtk::details::uv_base_node< T >
class	exprtk::details::sos_base_node< T >
class	exprtk::details::sosos_base_node< T >
class	exprtk::details::T0oT1oT2_base_node< T >
class	exprtk::details::T0oT1oT2oT3_base_node< T >
class	exprtk::details::unary_variable_node< T, Operation >
class	exprtk::details::uvouv_node< T >
class	exprtk::details::unary_branch_node< T, Operation >
struct	exprtk::details::is_const< T >
struct	exprtk::details::is_const< const T >
struct	exprtk::details::is_const_ref< T >
struct	exprtk::details::is_const_ref< const T & >
struct	exprtk::details::is_ref< T >
struct	exprtk::details::is_ref< T & >
struct	exprtk::details::is_ref< const T & >
struct	exprtk::details::param_to_str< State >
struct	exprtk::details::param_to_str< 0 >
struct	exprtk::details::T0oT1oT2process< T >
struct	exprtk::details::T0oT1oT2process< T >::mode0
struct	exprtk::details::T0oT1oT2process< T >::mode1
struct	exprtk::details::T0oT1oT20T3process< T >
struct	exprtk::details::T0oT1oT20T3process< T >::mode0
struct	exprtk::details::T0oT1oT20T3process< T >::mode1
struct	exprtk::details::T0oT1oT20T3process< T >::mode2
struct	exprtk::details::T0oT1oT20T3process< T >::mode3
struct	exprtk::details::T0oT1oT20T3process< T >::mode4
struct	exprtk::details::nodetype_T0oT1< T, T0, T1 >
struct	exprtk::details::nodetype_T0oT1< T, const T0 &, const T1 & >
struct	exprtk::details::nodetype_T0oT1< T, const T0 &, const T1 >
struct	exprtk::details::nodetype_T0oT1< T, const T0, const T1 & >
struct	exprtk::details::nodetype_T0oT1< T, T0 &, T1 & >
struct	exprtk::details::nodetype_T0oT1< T, const T0, const T1 >
struct	exprtk::details::nodetype_T0oT1< T, T0 &, const T1 >
struct	exprtk::details::nodetype_T0oT1< T, const T0, T1 & >
struct	exprtk::details::nodetype_T0oT1< T, const T0 &, T1 & >
struct	exprtk::details::nodetype_T0oT1< T, T0 &, const T1 & >
struct	exprtk::details::nodetype_T0oT1oT2< T, T0, T1, T2 >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0 &, const T1 &, const T2 & >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0 &, const T1 &, const T2 >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0 &, const T1, const T2 & >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0, const T1 &, const T2 & >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0, const T1 &, const T2 >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0, const T1, const T2 >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0, const T1, const T2 & >
struct	exprtk::details::nodetype_T0oT1oT2< T, const T0 &, const T1, const T2 >
struct	exprtk::details::nodetype_T0oT1oT2< T, T0 &, T1 &, T2 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, T0, T1, T2, T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2 &, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2 &, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2 &, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2 &, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2 &, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2 &, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2 &, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2, const T3 >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2 &, const T3 & >
struct	exprtk::details::nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2, const T3 >
class	exprtk::details::T0oT1< T, T0, T1 >
class	exprtk::details::T0oT1oT2< T, T0, T1, T2, ProcessMode >
class	exprtk::details::T0oT1oT2oT3< T, T0_, T1_, T2_, T3_, ProcessMode >
class	exprtk::details::T0oT1oT2_sf3< T, T0, T1, T2 >
class	exprtk::details::sf3ext_type_node< T, T0, T1, T2 >
class	exprtk::details::T0oT1oT2_sf3ext< T, T0, T1, T2, SF3Operation >
class	exprtk::details::T0oT1oT2oT3_sf4< T, T0, T1, T2, T3 >
class	exprtk::details::T0oT1oT2oT3_sf4ext< T, T0, T1, T2, T3, SF4Operation >
struct	exprtk::details::T0oT1_define< T, T0, T1 >
struct	exprtk::details::T0oT1oT2_define< T, T0, T1, T2 >
struct	exprtk::details::T0oT1oT2oT3_define< T, T0, T1, T2, T3 >
class	exprtk::details::vov_node< T, Operation >
class	exprtk::details::cov_node< T, Operation >
class	exprtk::details::voc_node< T, Operation >
class	exprtk::details::vob_node< T, Operation >
class	exprtk::details::bov_node< T, Operation >
class	exprtk::details::cob_node< T, Operation >
class	exprtk::details::boc_node< T, Operation >
class	exprtk::details::sos_node< T, SType0, SType1, Operation >
class	exprtk::details::str_xrox_node< T, SType0, SType1, RangePack, Operation >
class	exprtk::details::str_xoxr_node< T, SType0, SType1, RangePack, Operation >
class	exprtk::details::str_xroxr_node< T, SType0, SType1, RangePack, Operation >
class	exprtk::details::str_sogens_node< T, Operation >
class	exprtk::details::sosos_node< T, SType0, SType1, SType2, Operation >
class	exprtk::details::ipow_node< T, PowOp >
class	exprtk::details::bipow_node< T, PowOp >
class	exprtk::details::ipowinv_node< T, PowOp >
class	exprtk::details::bipowinv_node< T, PowOp >
class	exprtk::details::node_allocator
class	exprtk::function_traits
class	exprtk::ifunction< T >
class	exprtk::ivararg_function< T >
class	exprtk::igeneric_function< T >
class	exprtk::stringvar_base< T >
class	exprtk::symbol_table< T >
struct	exprtk::symbol_table< T >::freefunc00
struct	exprtk::symbol_table< T >::freefunc01
struct	exprtk::symbol_table< T >::freefunc02
struct	exprtk::symbol_table< T >::freefunc03
struct	exprtk::symbol_table< T >::freefunc04
struct	exprtk::symbol_table< T >::freefunc05
struct	exprtk::symbol_table< T >::freefunc06
struct	exprtk::symbol_table< T >::freefunc07
struct	exprtk::symbol_table< T >::freefunc08
struct	exprtk::symbol_table< T >::freefunc09
struct	exprtk::symbol_table< T >::freefunc10
struct	exprtk::symbol_table< T >::freefunc11
struct	exprtk::symbol_table< T >::freefunc12
struct	exprtk::symbol_table< T >::freefunc13
struct	exprtk::symbol_table< T >::freefunc14
struct	exprtk::symbol_table< T >::freefunc15
struct	exprtk::symbol_table< T >::type_store< Type, RawType >
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::deleter
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_array
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_stdvec
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_vecview
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::tie_stddeq
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::ptr_match< TType, TRawType, PtrType >
struct	exprtk::symbol_table< T >::type_store< Type, RawType >::ptr_match< TType, TRawType, variable_node_t * >
struct	exprtk::symbol_table< T >::control_block
struct	exprtk::symbol_table< T >::control_block::st_data
class	exprtk::expression< T >
struct	exprtk::expression< T >::control_block
struct	exprtk::expression< T >::control_block::data_pack
class	exprtk::expression_helper< T >
struct	exprtk::parser_error::type
class	exprtk::parser< T >
struct	exprtk::parser< T >::scope_element
class	exprtk::parser< T >::scope_element_manager
class	exprtk::parser< T >::scope_handler
struct	exprtk::parser< T >::halfopen_range_policy< T_ >
struct	exprtk::parser< T >::closed_range_policy< T_ >
class	exprtk::parser< T >::interval_container_t< IntervalPointType, RangePolicy >
class	exprtk::parser< T >::stack_limit_handler
struct	exprtk::parser< T >::symtab_store
struct	exprtk::parser< T >::symtab_store::variable_context
struct	exprtk::parser< T >::symtab_store::vector_context
struct	exprtk::parser< T >::symtab_store::string_context
struct	exprtk::parser< T >::parser_state
struct	exprtk::parser< T >::unknown_symbol_resolver
class	exprtk::parser< T >::dependent_entity_collector
class	exprtk::parser< T >::settings_store
struct	exprtk::parser< T >::state_t
struct	exprtk::parser< T >::scoped_expression_delete
struct	exprtk::parser< T >::scoped_delete< Type, N >
struct	exprtk::parser< T >::scoped_deq_delete< Type >
struct	exprtk::parser< T >::scoped_vec_delete< Type >
struct	exprtk::parser< T >::scoped_bool_negator
struct	exprtk::parser< T >::scoped_bool_or_restorer
struct	exprtk::parser< T >::scoped_inc_dec
class	exprtk::parser< T >::type_checker
struct	exprtk::parser< T >::type_checker::function_prototype_t
struct	exprtk::parser< T >::parse_special_function_impl< Type, NumberOfParameters >
class	exprtk::parser< T >::expression_generator< Type >
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_1
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_2
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_3
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_4
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_5
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_6
struct	exprtk::parser< T >::expression_generator< Type >::switch_nodes::switch_impl_7
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_binary_ext_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cocob_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_coboc_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vov_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cov_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_voc_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_sf3ext_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_sf4ext_expression
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_cocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococ_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococ_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression0
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression1
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression2
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression3
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovovoc_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vovocov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covocov_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vocovoc_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_covovoc_expression4
struct	exprtk::parser< T >::expression_generator< Type >::synthesize_vococov_expression4
struct	exprtk::details::collector_helper< T >
struct	exprtk::details::collector_helper< T >::resolve_as_vector
class	exprtk::polynomial< T, N >
struct	exprtk::polynomial< T, N >::poly_impl< Type, NumberOfCoefficients >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 12 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 11 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 10 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 9 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 8 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 7 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 6 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 5 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 4 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 3 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 2 >
struct	exprtk::polynomial< T, N >::poly_impl< Type, 1 >
class	exprtk::function_compositor< T >
struct	exprtk::function_compositor< T >::function
struct	exprtk::function_compositor< T >::base_func
struct	exprtk::function_compositor< T >::func_0param
struct	exprtk::function_compositor< T >::scoped_bft< BaseFuncType >
struct	exprtk::function_compositor< T >::func_1param
struct	exprtk::function_compositor< T >::func_2param
struct	exprtk::function_compositor< T >::func_3param
struct	exprtk::function_compositor< T >::func_4param
struct	exprtk::function_compositor< T >::func_5param
struct	exprtk::function_compositor< T >::func_6param
struct	exprtk::function_compositor< T >::func_0param_retval
struct	exprtk::function_compositor< T >::func_1param_retval
struct	exprtk::function_compositor< T >::func_2param_retval
struct	exprtk::function_compositor< T >::func_3param_retval
struct	exprtk::function_compositor< T >::func_4param_retval
struct	exprtk::function_compositor< T >::func_5param_retval
struct	exprtk::function_compositor< T >::func_6param_retval
class	exprtk::timer
struct	exprtk::type_defs< T >
struct	exprtk::rtl::io::details::print_impl< T >
struct	exprtk::rtl::io::print< T >
struct	exprtk::rtl::io::println< T >
struct	exprtk::rtl::io::package< T >
struct	exprtk::rtl::io::file::details::file_descriptor
class	exprtk::rtl::io::file::open< T >
struct	exprtk::rtl::io::file::close< T >
class	exprtk::rtl::io::file::write< T >
class	exprtk::rtl::io::file::read< T >
class	exprtk::rtl::io::file::getline< T >
struct	exprtk::rtl::io::file::eof< T >
struct	exprtk::rtl::io::file::package< T >
struct	exprtk::rtl::vecops::helper::load_vector_range< T >
class	exprtk::rtl::vecops::all_true< T >
class	exprtk::rtl::vecops::all_false< T >
class	exprtk::rtl::vecops::any_true< T >
class	exprtk::rtl::vecops::any_false< T >
class	exprtk::rtl::vecops::count< T >
class	exprtk::rtl::vecops::copy< T >
class	exprtk::rtl::vecops::rol< T >
class	exprtk::rtl::vecops::ror< T >
class	exprtk::rtl::vecops::shift_left< T >
class	exprtk::rtl::vecops::shift_right< T >
class	exprtk::rtl::vecops::sort< T >
class	exprtk::rtl::vecops::nthelement< T >
class	exprtk::rtl::vecops::assign< T >
class	exprtk::rtl::vecops::iota< T >
class	exprtk::rtl::vecops::sumk< T >
class	exprtk::rtl::vecops::axpy< T >
class	exprtk::rtl::vecops::axpby< T >
class	exprtk::rtl::vecops::axpyz< T >
class	exprtk::rtl::vecops::axpbyz< T >
class	exprtk::rtl::vecops::axpbsy< T >
class	exprtk::rtl::vecops::axpbsyz< T >
class	exprtk::rtl::vecops::axpbz< T >
class	exprtk::rtl::vecops::diff< T >
class	exprtk::rtl::vecops::dot< T >
class	exprtk::rtl::vecops::dotk< T >
class	exprtk::rtl::vecops::threshold_below< T >
class	exprtk::rtl::vecops::threshold_above< T >
struct	exprtk::rtl::vecops::package< T >

Namespaces
namespace	exprtk
namespace	exprtk::details
namespace	exprtk::details::numeric
namespace	exprtk::details::numeric::constant
namespace	exprtk::details::numeric::details
namespace	exprtk::lexer
namespace	exprtk::lexer::helper
namespace	exprtk::details::loop_unroll
namespace	exprtk::parser_error
namespace	exprtk::rtl
namespace	exprtk::rtl::io
namespace	exprtk::rtl::io::details
namespace	exprtk::rtl::io::file
namespace	exprtk::rtl::io::file::details
namespace	exprtk::rtl::vecops
namespace	exprtk::rtl::vecops::helper
namespace	exprtk::rtl::vecops::details
namespace	exprtk::information

Macros
#define	exprtk_debug(params)   (void)0
#define	exprtk_error_location    "exprtk.hpp:" + details::to_str(__LINE__) \
#define	exprtk_override
#define	exprtk_final
#define	exprtk_delete
#define	exprtk_fallthrough
#define	pod_set_zero_value(T)
#define	exprtk_register_real_type_tag(T)
#define	exprtk_register_int_type_tag(T)
#define	exprtk_define_epsilon_type(Type, Epsilon)
#define	exprtk_define_erf(TT, impl)    inline TT erf_impl(const TT v) { return impl(v); } \
#define	exprtk_define_erfc(TT, impl)    inline TT erfc_impl(const TT v) { return impl(v); } \
#define	exprtk_define_unary_function(FunctionName)
#define	exprtk_process_digit
#define	parse_digit_1(d)
#define	parse_digit_2(d)
#define	token_inserter_empty_body
#define	exprtk_loop(N)    std::swap(s0[N], s1[N]); \
#define	case_stmt(N)
#define	define_sfop3(NN, OP0, OP1)
#define	define_sfop4(NN, OP0, OP1)
#define	exprtk_loop(N)    vec[N] = v; \
#define	case_stmt(N)
#define	exprtk_loop(N)    vec0[N] = vec1[N]; \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    Operation::assign(vec[N],v); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec0[N] = Operation::process(vec0[N], vec1[N]); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec2[N] = Operation::process(vec0[N], vec1[N]); \
#define	case_stmt(N)
#define	exprtk_loop(N)    vec1[N] = Operation::process(vec0[N], v); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec0[N] = Operation::process(v, vec1[N]); \
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    vec1[N] = Operation::process(vec0[N]); \
#define	case_stmt(N)
#define	exprtk_define_unary_op(OpName)
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    r[N] += vec[N]; \
#define	case_stmt(N, fall_through)
#define	case_stmt(N, fall_through)
#define	exprtk_loop(N)    r[N] *= vec[N]; \
#define	case_stmt(N, fall_through)
#define	exprtk_crtype(Type)    param_to_str<is_const_ref< Type >::result>::result() \
#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	empty_method_body(N)
#define	igeneric_function_empty_body(N)
#define	exprtk_define_process(Type)
#define	exprtk_define_freefunction(NN)
#define	base_opr_case(N)
#define	register_synthezier(S)    synthesize_map_[S ::node_type::id()] = S ::process; \
#define	case_stmt(N)    if (is_true(arg[(2 * N)].first)) { return arg[(2 * N) + 1].first->value(); } \
#define	case_stmt(N)
#define	unary_opr_switch_statements
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op0, op1)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#define	case_stmt(op)
#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	batch_eqineq_logic_case
#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(op)
#define	case_stmt0(op)
#define	case_stmt1(op)
#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	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(value_type(Op,BinaryFunctor<T>::process)); \
#define	register_binary_op(Op, BinaryFunctor)    m.insert(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_sf3_extid(Id, Op)    sf3_map[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	poly_rtrn(NN)    return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :
#define	exprtk_assign(Index)    (*v[Index]) = v##Index; \
#define	def_fp_retval(N)
#define	case_stmt(N)
#define	exprtk_register_function(FunctionName, FunctionType)
#define	exprtk_register_function(FunctionName, FunctionType)
#define	exprtk_register_function(FunctionName, FunctionType)

Typedefs
typedef char	exprtk::details::char_t
typedef char_t *	exprtk::details::char_ptr
typedef char_t const *	exprtk::details::char_cptr
typedef unsigned char	exprtk::details::uchar_t
typedef uchar_t *	exprtk::details::uchar_ptr
typedef uchar_t const *	exprtk::details::uchar_cptr
typedef unsigned long long int	exprtk::details::_uint64_t
typedef long long int	exprtk::details::_int64_t
typedef loop_runtime_check *	exprtk::loop_runtime_check_ptr
typedef vector_access_runtime_check *	exprtk::vector_access_runtime_check_ptr
typedef compilation_check *	exprtk::compilation_check_ptr

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

Functions
bool	exprtk::details::is_whitespace (const char_t c)
bool	exprtk::details::is_operator_char (const char_t c)
bool	exprtk::details::is_letter (const char_t c)
bool	exprtk::details::is_digit (const char_t c)
bool	exprtk::details::is_letter_or_digit (const char_t c)
bool	exprtk::details::is_left_bracket (const char_t c)
bool	exprtk::details::is_right_bracket (const char_t c)
bool	exprtk::details::is_bracket (const char_t c)
bool	exprtk::details::is_sign (const char_t c)
bool	exprtk::details::is_invalid (const char_t c)
bool	exprtk::details::is_valid_string_char (const char_t c)
void	exprtk::details::case_normalise (std::string &s)
bool	exprtk::details::imatch (const char_t c1, const char_t c2)
bool	exprtk::details::imatch (const std::string &s1, const std::string &s2)
bool	exprtk::details::is_valid_sf_symbol (const std::string &symbol)
const char_t &	exprtk::details::front (const std::string &s)
const char_t &	exprtk::details::back (const std::string &s)
std::string	exprtk::details::to_str (int i)
std::string	exprtk::details::to_str (std::size_t i)
bool	exprtk::details::is_hex_digit (const uchar_t digit)
uchar_t	exprtk::details::hex_to_bin (uchar_t h)
template<typename Iterator >
bool	exprtk::details::parse_hex (Iterator &itr, Iterator end, char_t &result)
bool	exprtk::details::cleanup_escapes (std::string &s)
bool	exprtk::details::is_reserved_word (const std::string &symbol)
bool	exprtk::details::is_reserved_symbol (const std::string &symbol)
bool	exprtk::details::is_base_function (const std::string &function_name)
bool	exprtk::details::is_control_struct (const std::string &cntrl_strct)
bool	exprtk::details::is_logic_opr (const std::string &lgc_opr)
template<typename Iterator , typename Compare >
bool	exprtk::details::match_impl (const Iterator pattern_begin, const Iterator pattern_end, const Iterator data_begin, const Iterator data_end, const typename std::iterator_traits< Iterator >::value_type &zero_or_more, const typename std::iterator_traits< Iterator >::value_type &exactly_one)
bool	exprtk::details::wc_match (const std::string &wild_card, const std::string &str)
bool	exprtk::details::wc_imatch (const std::string &wild_card, const std::string &str)
bool	exprtk::details::sequence_match (const std::string &pattern, const std::string &str, std::size_t &diff_index, char_t &diff_value)
template<typename T >
void	exprtk::details::set_zero_value (T *data, const std::size_t size)
template<typename T >
void	exprtk::details::set_zero_value (std::vector< T > &v)
template<typename T >
bool	exprtk::details::numeric::details::is_nan_impl (const T v, real_type_tag)
template<typename T >
int	exprtk::details::numeric::details::to_int32_impl (const T v, real_type_tag)
template<typename T >
_int64_t	exprtk::details::numeric::details::to_int64_impl (const T v, real_type_tag)
template<typename T >
_uint64_t	exprtk::details::numeric::details::to_uint64_impl (const T v, real_type_tag)
template<typename T >
bool	exprtk::details::numeric::details::is_true_impl (const T v)
template<typename T >
bool	exprtk::details::numeric::details::is_false_impl (const T v)
template<typename T >
T	exprtk::details::numeric::details::abs_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::min_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::max_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::equal_impl (const T v0, const T v1, real_type_tag)
float	exprtk::details::numeric::details::equal_impl (const float v0, const float v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::equal_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::expm1_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::expm1_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nequal_impl (const T v0, const T v1, real_type_tag)
float	exprtk::details::numeric::details::nequal_impl (const float v0, const float v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nequal_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::modulus_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::modulus_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pow_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pow_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::logn_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::logn_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log1p_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log1p_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::root_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::root_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::round_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::roundn_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::roundn_impl (const T v0, const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::hypot_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::hypot_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan2_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan2_impl (const T, const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shr_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shr_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shl_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::shl_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sgn_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sgn_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::and_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::and_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nand_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nand_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::or_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::or_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nor_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::nor_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xor_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xor_impl (const T v0, const T v1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xnor_impl (const T v0, const T v1, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::xnor_impl (const T v0, const T v1, int_type_tag)
float	exprtk::details::numeric::details::erf_impl (const float v)
double	exprtk::details::numeric::details::erf_impl (const double v)
long double	exprtk::details::numeric::details::erf_impl (const long double v)
template<typename T >
T	exprtk::details::numeric::details::erf_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::erf_impl (const T v, int_type_tag)
float	exprtk::details::numeric::details::erfc_impl (const float v)
double	exprtk::details::numeric::details::erfc_impl (const double v)
long double	exprtk::details::numeric::details::erfc_impl (const long double v)
template<typename T >
T	exprtk::details::numeric::details::erfc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::erfc_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ncdf_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ncdf_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinc_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acos_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acosh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asin_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asinh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atanh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ceil_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cos_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cosh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::exp_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::floor_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log10_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log2_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::neg_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pos_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sin_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sqrt_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tan_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tanh_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cot_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sec_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::csc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::r2d_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::d2r_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::d2g_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::g2d_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::notl_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::frac_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::trunc_impl (const T v, real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::const_pi_impl (real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::const_e_impl (real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::const_qnan_impl (real_type_tag)
template<typename T >
T	exprtk::details::numeric::details::abs_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::exp_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log10_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::log2_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::neg_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::pos_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::ceil_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::floor_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::round_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::notl_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sqrt_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::frac_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::trunc_impl (const T v, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acos_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::acosh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asin_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::asinh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atan_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::atanh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cos_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cosh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sin_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sinh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tan_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::tanh_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::cot_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::sec_impl (const T, int_type_tag)
template<typename T >
T	exprtk::details::numeric::details::csc_impl (const T, int_type_tag)
template<typename T >
bool	exprtk::details::numeric::details::is_integer_impl (const T &v, real_type_tag)
template<typename T >
bool	exprtk::details::numeric::details::is_integer_impl (const T &, int_type_tag)
template<typename T >
int	exprtk::details::numeric::to_int32 (const T v)
template<typename T >
_int64_t	exprtk::details::numeric::to_int64 (const T v)
template<typename T >
_uint64_t	exprtk::details::numeric::to_uint64 (const T v)
template<typename T >
bool	exprtk::details::numeric::is_nan (const T v)
template<typename T >
T	exprtk::details::numeric::min (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::max (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::equal (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::nequal (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::modulus (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::pow (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::logn (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::root (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::roundn (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::hypot (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::atan2 (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::shr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::shl (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::and_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::nand_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::or_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::nor_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::xor_opr (const T v0, const T v1)
template<typename T >
T	exprtk::details::numeric::xnor_opr (const T v0, const T v1)
template<typename T >
bool	exprtk::details::numeric::is_integer (const T v)
template<typename T >
T	exprtk::details::numeric::abs (const T v)
template<typename T >
T	exprtk::details::numeric::acos (const T v)
template<typename T >
T	exprtk::details::numeric::acosh (const T v)
template<typename T >
T	exprtk::details::numeric::asin (const T v)
template<typename T >
T	exprtk::details::numeric::asinh (const T v)
template<typename T >
T	exprtk::details::numeric::atan (const T v)
template<typename T >
T	exprtk::details::numeric::atanh (const T v)
template<typename T >
T	exprtk::details::numeric::ceil (const T v)
template<typename T >
T	exprtk::details::numeric::cos (const T v)
template<typename T >
T	exprtk::details::numeric::cosh (const T v)
template<typename T >
T	exprtk::details::numeric::exp (const T v)
template<typename T >
T	exprtk::details::numeric::expm1 (const T v)
template<typename T >
T	exprtk::details::numeric::floor (const T v)
template<typename T >
T	exprtk::details::numeric::log (const T v)
template<typename T >
T	exprtk::details::numeric::log10 (const T v)
template<typename T >
T	exprtk::details::numeric::log2 (const T v)
template<typename T >
T	exprtk::details::numeric::log1p (const T v)
template<typename T >
T	exprtk::details::numeric::neg (const T v)
template<typename T >
T	exprtk::details::numeric::pos (const T v)
template<typename T >
T	exprtk::details::numeric::round (const T v)
template<typename T >
T	exprtk::details::numeric::sin (const T v)
template<typename T >
T	exprtk::details::numeric::sinc (const T v)
template<typename T >
T	exprtk::details::numeric::sinh (const T v)
template<typename T >
T	exprtk::details::numeric::sqrt (const T v)
template<typename T >
T	exprtk::details::numeric::tan (const T v)
template<typename T >
T	exprtk::details::numeric::tanh (const T v)
template<typename T >
T	exprtk::details::numeric::cot (const T v)
template<typename T >
T	exprtk::details::numeric::sec (const T v)
template<typename T >
T	exprtk::details::numeric::csc (const T v)
template<typename T >
T	exprtk::details::numeric::r2d (const T v)
template<typename T >
T	exprtk::details::numeric::d2r (const T v)
template<typename T >
T	exprtk::details::numeric::d2g (const T v)
template<typename T >
T	exprtk::details::numeric::g2d (const T v)
template<typename T >
T	exprtk::details::numeric::notl (const T v)
template<typename T >
T	exprtk::details::numeric::sgn (const T v)
template<typename T >
T	exprtk::details::numeric::erf (const T v)
template<typename T >
T	exprtk::details::numeric::erfc (const T v)
template<typename T >
T	exprtk::details::numeric::ncdf (const T v)
template<typename T >
T	exprtk::details::numeric::frac (const T v)
template<typename T >
T	exprtk::details::numeric::trunc (const T v)
template<typename T >
T	exprtk::details::compute_pow10 (T d, const int exponent)
template<typename Iterator , typename T >
bool	exprtk::details::string_to_type_converter_impl_ref (Iterator &itr, const Iterator end, T &result)
template<typename Iterator , typename T >
static bool	exprtk::details::parse_nan (Iterator &itr, const Iterator end, T &t)
template<typename Iterator , typename T >
static bool	exprtk::details::parse_inf (Iterator &itr, const Iterator end, T &t, const bool negative)
template<typename T >
bool	exprtk::details::valid_exponent (const int exponent, numeric::details::real_type_tag)
template<typename Iterator , typename T >
bool	exprtk::details::string_to_real (Iterator &itr_external, const Iterator end, T &t, numeric::details::real_type_tag)
template<typename T >
bool	exprtk::details::string_to_real (const std::string &s, T &t)
void	exprtk::lexer::helper::dump (const lexer::generator &generator)
template<typename T >
vector_view< T >	exprtk::make_vector_view (T *data, const std::size_t size, const std::size_t offset=0)
template<typename T >
vector_view< T >	exprtk::make_vector_view (std::vector< T > &v, const std::size_t size, const std::size_t offset=0)
template<typename StringView >
std::string	exprtk::to_str (const StringView &view)
std::string	exprtk::details::to_str (const operator_type opr)
void	exprtk::details::dump_ptr (const std::string &, const void *)
void	exprtk::details::dump_ptr (const std::string &, const void *, const std::size_t)
template<typename T >
void	exprtk::details::dump_vector (const std::string &, const T *, const std::size_t)
template<typename T >
T	exprtk::details::numeric::details::process_impl (const operator_type operation, const T arg)
template<typename T >
T	exprtk::details::numeric::details::process_impl (const operator_type operation, const T arg0, const T arg1)
template<typename T >
T	exprtk::details::numeric::details::process_impl (const operator_type operation, const T arg0, const T arg1, int_type_tag)
template<typename T >
T	exprtk::details::numeric::process (const operator_type operation, const T arg)
template<typename T >
T	exprtk::details::numeric::process (const operator_type operation, const T arg0, const T arg1)
template<typename T >
bool	exprtk::details::is_generally_string_node (const expression_node< T > *node)
bool	exprtk::details::is_true (const double v)
bool	exprtk::details::is_true (const long double v)
bool	exprtk::details::is_true (const float v)
template<typename T >
bool	exprtk::details::is_true (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_true (const std::pair< expression_node< T > *, bool > &node)
template<typename T >
bool	exprtk::details::is_false (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_false (const std::pair< expression_node< T > *, bool > &node)
template<typename T >
bool	exprtk::details::is_literal_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_unary_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_neg_unary_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_binary_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_variable_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_ivariable_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_elem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_celem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_elem_rtc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_celem_rtc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_elem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_elem_rtc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_celem_rtc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_rebasevector_celem_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_vector_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_ivector_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_constant_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_null_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_break_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_continue_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_swap_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_function (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_return_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_negate_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::branch_deletable (const expression_node< T > *node)
template<std::size_t N, typename T >
bool	exprtk::details::all_nodes_valid (expression_node< T > *const (&b)[N])
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::details::all_nodes_valid (const Sequence< expression_node< T > *, Allocator > &b)
template<std::size_t N, typename T >
bool	exprtk::details::all_nodes_variables (expression_node< T > *const (&b)[N])
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::details::all_nodes_variables (const Sequence< expression_node< T > *, Allocator > &b)
template<typename NodeAllocator , typename T , std::size_t N>
void	exprtk::details::free_all_nodes (NodeAllocator &node_allocator, expression_node< T > *(&b)[N])
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)
template<typename NodeAllocator , typename T >
void	exprtk::details::free_node (NodeAllocator &, expression_node< T > *&node)
template<typename T >
void	exprtk::details::destroy_node (expression_node< T > *&node)
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)
template<typename T >
void	exprtk::details::construct_branch_pair (std::pair< expression_node< T > *, bool > &branch, expression_node< T > *b)
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))
template<typename T , std::size_t N>
T	exprtk::details::axn (const T a, const T x)
template<typename T , std::size_t N>
T	exprtk::details::axnb (const T a, const T x, const T b)
template<typename T >
memory_context_t< T >	exprtk::details::make_memory_context (vector_holder< T > &vec_holder, vec_data_store< T > &vds)
template<typename T >
memory_context_t< T >	exprtk::details::make_memory_context (vector_holder< T > &vec_holder0, vector_holder< T > &vec_holder1, vec_data_store< T > &vds)
template<typename T >
T	exprtk::details::value (details::expression_node< T > *n)
template<typename T >
T	exprtk::details::value (std::pair< details::expression_node< T > *, bool > n)
template<typename T >
T	exprtk::details::value (const T *t)
template<typename T >
T	exprtk::details::value (const T &t)
template<typename T >
bool	exprtk::details::is_sf3ext_node (const expression_node< T > *n)
template<typename T >
bool	exprtk::details::is_sf4ext_node (const expression_node< T > *n)
template<typename T >
bool	exprtk::details::is_vov_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_cov_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_voc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_cob_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_boc_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_t0ot1ot2_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_t0ot1ot2ot3_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_uv_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_range_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_const_string_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_const_string_range_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_assignment_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_concat_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_function_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_condition_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_ccondition_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_string_vararg_node (const expression_node< T > *node)
template<typename T >
bool	exprtk::details::is_genricstring_range_node (const expression_node< T > *node)
void	exprtk::details::load_operations_map (std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)
template<typename FunctionType >
void	exprtk::enable_zero_parameters (FunctionType &func)
template<typename FunctionType >
void	exprtk::disable_zero_parameters (FunctionType &func)
template<typename FunctionType >
void	exprtk::enable_has_side_effects (FunctionType &func)
template<typename FunctionType >
void	exprtk::disable_has_side_effects (FunctionType &func)
template<typename FunctionType >
void	exprtk::set_min_num_args (FunctionType &func, const std::size_t &num_args)
template<typename FunctionType >
void	exprtk::set_max_num_args (FunctionType &func, const std::size_t &num_args)
template<typename T >
bool	exprtk::is_valid (const expression< T > &expr)
type	exprtk::parser_error::make_error (const error_mode mode, const std::string &diagnostic="", const std::string &src_location="")
type	exprtk::parser_error::make_error (const error_mode mode, const lexer::token &tk, const std::string &diagnostic="", const std::string &src_location="")
std::string	exprtk::parser_error::to_str (error_mode mode)
bool	exprtk::parser_error::update_error (type &error, const std::string &expression)
void	exprtk::parser_error::dump_error (const type &error)
template<typename Parser >
void	exprtk::details::disable_type_checking (Parser &p)
template<typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_variables (const std::string &expression, Sequence< std::string, Allocator > &symbol_list)
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_variables (const std::string &expression, exprtk::symbol_table< T > &extrnl_symbol_table, Sequence< std::string, Allocator > &symbol_list)
template<typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_functions (const std::string &expression, Sequence< std::string, Allocator > &symbol_list)
template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	exprtk::collect_functions (const std::string &expression, exprtk::symbol_table< T > &extrnl_symbol_table, Sequence< std::string, Allocator > &symbol_list)
template<typename T >
T	exprtk::integrate (const 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 (const 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 (const expression< T > &e, T &x, const T &h=T(0.00000001))
template<typename T >
T	exprtk::second_derivative (const expression< T > &e, T &x, const T &h=T(0.00001))
template<typename T >
T	exprtk::third_derivative (const expression< T > &e, T &x, const T &h=T(0.0001))
template<typename T >
T	exprtk::derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.00000001))
template<typename T >
T	exprtk::second_derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.00001))
template<typename T >
T	exprtk::third_derivative (const 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 >
void	exprtk::rtl::io::details::print_type (const std::string &fmt, const T v, exprtk::details::numeric::details::real_type_tag)
template<typename T >
file_descriptor *	exprtk::rtl::io::file::details::make_handle (T v)
template<typename T >
void	exprtk::rtl::io::file::details::perform_check ()
template<typename Vector >
bool	exprtk::rtl::vecops::helper::invalid_range (const Vector &v, const std::size_t r0, const std::size_t r1)
template<typename T >
void	exprtk::rtl::vecops::details::kahan_sum (T &sum, T &error, const T v)
static std::string	exprtk::information::data ()

Variables
static const std::string	exprtk::details::reserved_words []
static const std::size_t	exprtk::details::reserved_words_size = sizeof(reserved_words) / sizeof(std::string)
static const std::string	exprtk::details::reserved_symbols []
static const std::size_t	exprtk::details::reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string)
static const std::string	exprtk::details::base_function_list []
static const std::size_t	exprtk::details::base_function_list_size = sizeof(base_function_list) / sizeof(std::string)
static const std::string	exprtk::details::logic_ops_list []
static const std::size_t	exprtk::details::logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string)
static const std::string	exprtk::details::cntrl_struct_list []
static const std::size_t	exprtk::details::cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string)
static const std::string	exprtk::details::arithmetic_ops_list []
static const std::size_t	exprtk::details::arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string)
static const std::string	exprtk::details::assignment_ops_list []
static const std::size_t	exprtk::details::assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string)
static const std::string	exprtk::details::inequality_ops_list []
static const std::size_t	exprtk::details::inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string)
static const double	exprtk::details::pow10 []
static const std::size_t	exprtk::details::pow10_size = sizeof(pow10) / sizeof(double)
static const double	exprtk::details::numeric::constant::e = 2.71828182845904523536028747135266249775724709369996
static const double	exprtk::details::numeric::constant::pi = 3.14159265358979323846264338327950288419716939937510
static const double	exprtk::details::numeric::constant::pi_2 = 1.57079632679489661923132169163975144209858469968755
static const double	exprtk::details::numeric::constant::pi_4 = 0.78539816339744830961566084581987572104929234984378
static const double	exprtk::details::numeric::constant::pi_180 = 0.01745329251994329576923690768488612713442871888542
static const double	exprtk::details::numeric::constant::_1_pi = 0.31830988618379067153776752674502872406891929148091
static const double	exprtk::details::numeric::constant::_2_pi = 0.63661977236758134307553505349005744813783858296183
static const double	exprtk::details::numeric::constant::_180_pi = 57.29577951308232087679815481410517033240547246656443
static const double	exprtk::details::numeric::constant::log2 = 0.69314718055994530941723212145817656807550013436026
static const double	exprtk::details::numeric::constant::sqrt2 = 1.41421356237309504880168872420969807856967187537695
const unsigned int	exprtk::details::loop_unroll::global_loop_batch_size
static char_cptr	exprtk::information::library = "Mathematical Expression Toolkit"
static char_cptr	exprtk::information::version
static char_cptr	exprtk::information::date = "20240101"
static char_cptr	exprtk::information::min_cpp = "199711L"

Macro Definition Documentation

base_opr_case

#define base_opr_case

(

N

)

Value:

                     case N : {                                                       \
                                 expression_node_ptr pl##N[N] = {0};                  \
                                 std::copy(param_list, param_list + N, pl##N);        \
                                 lodge_symbol(operation_name, e_st_function);         \
                                 return expression_generator_(operation.type, pl##N); \
                              }                                                       \

basic_opr_switch_statements

#define basic_opr_switch_statements

Value:

         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 33218 of file exprtk.hpp.

         {
            switch (p)
            {
               #define case_stmt(cp)                                                     \
               case cp : return node_allocator_->                                        \
                            allocate<IPowNode<T,details::numeric::fast_exp<T,cp> > >(v); \
 
               case_stmt( 1) case_stmt( 2) case_stmt( 3) case_stmt( 4)
               case_stmt( 5) case_stmt( 6) case_stmt( 7) case_stmt( 8)
               case_stmt( 9) case_stmt(10) case_stmt(11) case_stmt(12)
               case_stmt(13) case_stmt(14) case_stmt(15) case_stmt(16)
               case_stmt(17) case_stmt(18) case_stmt(19) case_stmt(20)
               case_stmt(21) case_stmt(22) case_stmt(23) case_stmt(24)
               case_stmt(25) case_stmt(26) case_stmt(27) case_stmt(28)
               case_stmt(29) case_stmt(30) case_stmt(31) case_stmt(32)
               case_stmt(33) case_stmt(34) case_stmt(35) case_stmt(36)
               case_stmt(37) case_stmt(38) case_stmt(39) case_stmt(40)
               case_stmt(41) case_stmt(42) case_stmt(43) case_stmt(44)
               case_stmt(45) case_stmt(46) case_stmt(47) case_stmt(48)
               case_stmt(49) case_stmt(50) case_stmt(51) case_stmt(52)
               case_stmt(53) case_stmt(54) case_stmt(55) case_stmt(56)
               case_stmt(57) case_stmt(58) case_stmt(59) case_stmt(60)
               #undef case_stmt
               default : return error_node();
            }
         }
 
         inline expression_node_ptr cardinal_pow_optimisation(const T& v, const T& c)
         {
            const bool not_recipricol = (c >= T(0));
            const unsigned int p = static_cast<unsigned int>(details::numeric::to_int32(details::numeric::abs(c)));
 
            if (0 == p)
               return node_allocator_->allocate_c<literal_node_t>(T(1));
            else if (std::equal_to<T>()(T(2),c))
            {
               return node_allocator_->
                  template allocate_rr<typename details::vov_node<Type,details::mul_op<Type> > >(v,v);
            }
            else
            {
               if (not_recipricol)
                  return cardinal_pow_optimisation_impl<T,details::ipow_node>(v,p);
               else
                  return cardinal_pow_optimisation_impl<T,details::ipowinv_node>(v,p);
            }
         }
 
         inline bool cardinal_pow_optimisable(const details::operator_type& operation, const T& c) const
         {
            return (details::e_pow == operation) && (details::numeric::abs(c) <= T(60)) && details::numeric::is_integer(c);
         }
 
         inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr (&branch)[2])
         {
            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
            const bool not_recipricol = (c >= T(0));
            const unsigned int p = static_cast<unsigned int>(details::numeric::to_int32(details::numeric::abs(c)));
 
            node_allocator_->free(branch[1]);
 
            if (0 == p)
            {
               details::free_all_nodes(*node_allocator_, branch);
 
               return node_allocator_->allocate_c<literal_node_t>(T(1));
            }
            else if (not_recipricol)
               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipow_node>(branch[0],p);
            else
               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipowinv_node>(branch[0],p);
         }
         #else
         inline expression_node_ptr cardinal_pow_optimisation(T&, const T&)
         {
            return error_node();
         }
 
         inline bool cardinal_pow_optimisable(const details::operator_type&, const T&)
         {
            return false;
         }
 
         inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr(&)[2])
         {
            return error_node();
         }
         #endif
 
         struct synthesize_binary_ext_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const bool left_neg  = is_neg_unary_node(branch[0]);
               const bool right_neg = is_neg_unary_node(branch[1]);
 
               if (left_neg && right_neg)
               {
                  if (
                       (details::e_add == operation) ||
                       (details::e_sub == operation) ||
                       (details::e_mul == operation) ||
                       (details::e_div == operation)
                     )
                  {
                     if (
                          !expr_gen.parser_->simplify_unary_negation_branch(branch[0]) ||
                          !expr_gen.parser_->simplify_unary_negation_branch(branch[1])
                        )
                     {
                        details::free_all_nodes(*expr_gen.node_allocator_,branch);
 
                        return error_node();
                     }
                  }
 
                  switch (operation)
                  {
                                           // -f(x + 1) + -g(y + 1) --> -(f(x + 1) + g(y + 1))
                     case details::e_add : return expr_gen(details::e_neg,
                                              expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
                                                    (branch[0],branch[1]));
 
                                           // -f(x + 1) - -g(y + 1) --> g(y + 1) - f(x + 1)
                     case details::e_sub : return expr_gen.node_allocator_->
                                              template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
                                                 (branch[1],branch[0]);
 
                     default             : break;
                  }
               }
               else if (left_neg && !right_neg)
               {
                  if (
                       (details::e_add == operation) ||
                       (details::e_sub == operation) ||
                       (details::e_mul == operation) ||
                       (details::e_div == operation)
                     )
                  {
                     if (!expr_gen.parser_->simplify_unary_negation_branch(branch[0]))
                     {
                        details::free_all_nodes(*expr_gen.node_allocator_,branch);
 
                        return error_node();
                     }
 
                     switch (operation)
                     {
                                              // -f(x + 1) + g(y + 1) --> g(y + 1) - f(x + 1)
                        case details::e_add : return expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
                                                   (branch[1], branch[0]);
 
                                              // -f(x + 1) - g(y + 1) --> -(f(x + 1) + g(y + 1))
                        case details::e_sub : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
                                                       (branch[0], branch[1]));
 
                                              // -f(x + 1) * g(y + 1) --> -(f(x + 1) * g(y + 1))
                        case details::e_mul : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::mul_op<Type> > >
                                                       (branch[0], branch[1]));
 
                                              // -f(x + 1) / g(y + 1) --> -(f(x + 1) / g(y + 1))
                        case details::e_div : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::div_op<Type> > >
                                                       (branch[0], branch[1]));
 
                        default             : return error_node();
                     }
                  }
               }
               else if (!left_neg && right_neg)
               {
                  if (
                       (details::e_add == operation) ||
                       (details::e_sub == operation) ||
                       (details::e_mul == operation) ||
                       (details::e_div == operation)
                     )
                  {
                     if (!expr_gen.parser_->simplify_unary_negation_branch(branch[1]))
                     {
                        details::free_all_nodes(*expr_gen.node_allocator_,branch);
 
                        return error_node();
                     }
 
                     switch (operation)
                     {
                                              // f(x + 1) + -g(y + 1) --> f(x + 1) - g(y + 1)
                        case details::e_add : return expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::sub_op<Type> > >
                                                   (branch[0], branch[1]);
 
                                              // f(x + 1) - - g(y + 1) --> f(x + 1) + g(y + 1)
                        case details::e_sub : return expr_gen.node_allocator_->
                                                 template allocate<typename details::binary_ext_node<Type,details::add_op<Type> > >
                                                   (branch[0], branch[1]);
 
                                              // f(x + 1) * -g(y + 1) --> -(f(x + 1) * g(y + 1))
                        case details::e_mul : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::mul_op<Type> > >
                                                       (branch[0], branch[1]));
 
                                              // f(x + 1) / -g(y + 1) --> -(f(x + 1) / g(y + 1))
                        case details::e_div : return expr_gen(details::e_neg,
                                                 expr_gen.node_allocator_->
                                                    template allocate<typename details::binary_ext_node<Type,details::div_op<Type> > >
                                                       (branch[0], branch[1]));
 
                        default             : return error_node();
                     }
                  }
               }
 
               switch (operation)
               {
                  #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]);                                             \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_vob_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type& v = static_cast<details::variable_node<Type>*>(branch[0])->ref();
 
               #ifndef exprtk_disable_enhanced_features
               if (details::is_sf3ext_node(branch[1]))
               {
                  expression_node_ptr result = error_node();
 
                  const bool synthesis_result =
                     synthesize_sf4ext_expression::template compile_right<vtype>
                        (expr_gen, v, operation, branch[1], result);
 
                  if (synthesis_result)
                  {
                     details::free_node(*expr_gen.node_allocator_,branch[1]);
                     return result;
                  }
               }
               #endif
 
               if (
                    (details::e_mul == operation) ||
                    (details::e_div == operation)
                  )
               {
                  if (details::is_uv_node(branch[1]))
                  {
                     typedef details::uv_base_node<Type>* uvbn_ptr_t;
 
                     details::operator_type o = static_cast<uvbn_ptr_t>(branch[1])->operation();
 
                     if (details::e_neg == o)
                     {
                        const Type& v1 = static_cast<uvbn_ptr_t>(branch[1])->v();
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
 
                        switch (operation)
                        {
                           case details::e_mul : return expr_gen(details::e_neg,
                                                    expr_gen.node_allocator_->
                                                       template allocate_rr<typename details::
                                                          vov_node<Type,details::mul_op<Type> > >(v,v1));
 
                           case details::e_div : return expr_gen(details::e_neg,
                                                    expr_gen.node_allocator_->
                                                       template allocate_rr<typename details::
                                                          vov_node<Type,details::div_op<Type> > >(v,v1));
 
                           default             : break;
                        }
                     }
                  }
               }
 
               switch (operation)
               {
                  #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]);                                                 \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_bov_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type& v = static_cast<details::variable_node<Type>*>(branch[1])->ref();
 
               #ifndef exprtk_disable_enhanced_features
               if (details::is_sf3ext_node(branch[0]))
               {
                  expression_node_ptr result = error_node();
 
                  const bool synthesis_result =
                     synthesize_sf4ext_expression::template compile_left<vtype>
                        (expr_gen, v, operation, branch[0], result);
 
                  if (synthesis_result)
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
 
                     return result;
                  }
               }
               #endif
 
               if (
                    (details::e_add == operation) ||
                    (details::e_sub == operation) ||
                    (details::e_mul == operation) ||
                    (details::e_div == operation)
                  )
               {
                  if (details::is_uv_node(branch[0]))
                  {
                     typedef details::uv_base_node<Type>* uvbn_ptr_t;
 
                     details::operator_type o = static_cast<uvbn_ptr_t>(branch[0])->operation();
 
                     if (details::e_neg == o)
                     {
                        const Type& v0 = static_cast<uvbn_ptr_t>(branch[0])->v();
 
                        details::free_node(*expr_gen.node_allocator_,branch[0]);
 
                        switch (operation)
                        {
                           case details::e_add : return expr_gen.node_allocator_->
                                                    template allocate_rr<typename details::
                                                       vov_node<Type,details::sub_op<Type> > >(v,v0);
 
                           case details::e_sub : return expr_gen(details::e_neg,
                                                    expr_gen.node_allocator_->
                                                       template allocate_rr<typename details::
                                                          vov_node<Type,details::add_op<Type> > >(v0,v));
 
                           case details::e_mul : return expr_gen(details::e_neg,
                                                    expr_gen.node_allocator_->
                                                       template allocate_rr<typename details::
                                                          vov_node<Type,details::mul_op<Type> > >(v0,v));
 
                           case details::e_div : return expr_gen(details::e_neg,
                                                    expr_gen.node_allocator_->
                                                       template allocate_rr<typename details::
                                                          vov_node<Type,details::div_op<Type> > >(v0,v));
                           default : break;
                        }
                     }
                  }
               }
 
               switch (operation)
               {
                  #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);                                                 \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_cob_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value();
 
               details::free_node(*expr_gen.node_allocator_,branch[0]);
 
               if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation))
               {
                  details::free_node(*expr_gen.node_allocator_,branch[1]);
 
                  return expr_gen(T(0));
               }
               else if (std::equal_to<T>()(T(0),c) && (details::e_div == operation))
               {
                  details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                  return expr_gen(T(0));
               }
               else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation))
                  return branch[1];
               else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation))
                  return branch[1];
 
               if (details::is_cob_node(branch[1]))
               {
                  // Simplify expressions of the form:
                  // 1. (1 * (2 * (3 * (4 * (5 * (6 * (7 * (8 * (9 + x))))))))) --> 40320 * (9 + x)
                  // 2. (1 + (2 + (3 + (4 + (5 + (6 + (7 + (8 + (9 + x))))))))) --> 45 + x
                  if (
                       (details::e_mul == operation) ||
                       (details::e_add == operation)
                     )
                  {
                     details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[1]);
 
                     if (operation == cobnode->operation())
                     {
                        switch (operation)
                        {
                           case details::e_add : cobnode->set_c(c + cobnode->c()); break;
                           case details::e_mul : cobnode->set_c(c * cobnode->c()); break;
                           default             : return error_node();
                        }
 
                        return cobnode;
                     }
                  }
 
                  if (operation == details::e_mul)
                  {
                     details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[1]);
                     details::operator_type cob_opr = cobnode->operation();
 
                     if (
                          (details::e_div == cob_opr) ||
                          (details::e_mul == cob_opr)
                        )
                     {
                        switch (cob_opr)
                        {
                           case details::e_div : cobnode->set_c(c * cobnode->c()); break;
                           case details::e_mul : cobnode->set_c(cobnode->c() / c); break;
                           default             : return error_node();
                        }
 
                        return cobnode;
                     }
                  }
                  else if (operation == details::e_div)
                  {
                     details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[1]);
                     details::operator_type cob_opr = cobnode->operation();
 
                     if (
                          (details::e_div == cob_opr) ||
                          (details::e_mul == cob_opr)
                        )
                     {
                        details::expression_node<Type>* new_cobnode = error_node();
 
                        switch (cob_opr)
                        {
                           case details::e_div : new_cobnode = expr_gen.node_allocator_->
                                                    template allocate_tt<typename details::cob_node<Type,details::mul_op<Type> > >
                                                       (c / cobnode->c(), cobnode->move_branch(0));
                                                 break;
 
                           case details::e_mul : new_cobnode = expr_gen.node_allocator_->
                                                    template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                                       (c / cobnode->c(), cobnode->move_branch(0));
                                                 break;
 
                           default             : return error_node();
                        }
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
 
                        return new_cobnode;
                     }
                  }
               }
               #ifndef exprtk_disable_enhanced_features
               else if (details::is_sf3ext_node(branch[1]))
               {
                  expression_node_ptr result = error_node();
 
                  const bool synthesis_result =
                     synthesize_sf4ext_expression::template compile_right<ctype>
                        (expr_gen, c, operation, branch[1], result);
 
                  if (synthesis_result)
                  {
                     details::free_node(*expr_gen.node_allocator_,branch[1]);
 
                     return result;
                  }
               }
               #endif
 
               switch (operation)
               {
                  #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]);                                                \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_boc_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
 
               details::free_node(*(expr_gen.node_allocator_), branch[1]);
 
               if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation))
               {
                  details::free_node(*expr_gen.node_allocator_, branch[0]);
 
                  return expr_gen(T(0));
               }
               else if (std::equal_to<T>()(T(0),c) && (details::e_div == operation))
               {
                  details::free_node(*expr_gen.node_allocator_, branch[0]);
 
                  return expr_gen(std::numeric_limits<T>::quiet_NaN());
               }
               else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation))
                  return branch[0];
               else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation))
                  return branch[0];
 
               if (details::is_boc_node(branch[0]))
               {
                  // Simplify expressions of the form:
                  // 1. (((((((((x + 9) * 8) * 7) * 6) * 5) * 4) * 3) * 2) * 1) --> (x + 9) * 40320
                  // 2. (((((((((x + 9) + 8) + 7) + 6) + 5) + 4) + 3) + 2) + 1) --> x + 45
                  if (
                       (details::e_mul == operation) ||
                       (details::e_add == operation)
                     )
                  {
                     details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]);
 
                     if (operation == bocnode->operation())
                     {
                        switch (operation)
                        {
                           case details::e_add : bocnode->set_c(c + bocnode->c()); break;
                           case details::e_mul : bocnode->set_c(c * bocnode->c()); break;
                           default             : return error_node();
                        }
 
                        return bocnode;
                     }
                  }
                  else if (operation == details::e_div)
                  {
                     details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]);
                     details::operator_type        boc_opr = bocnode->operation();
 
                     if (
                          (details::e_div == boc_opr) ||
                          (details::e_mul == boc_opr)
                        )
                     {
                        switch (boc_opr)
                        {
                           case details::e_div : bocnode->set_c(c * bocnode->c()); break;
                           case details::e_mul : bocnode->set_c(bocnode->c() / c); break;
                           default             : return error_node();
                        }
 
                        return bocnode;
                     }
                  }
                  else if (operation == details::e_pow)
                  {
                     // (v ^ c0) ^ c1 --> v ^(c0 * c1)
                     details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]);
                     details::operator_type        boc_opr = bocnode->operation();
 
                     if (details::e_pow == boc_opr)
                     {
                        bocnode->set_c(bocnode->c() * c);
 
                        return bocnode;
                     }
                  }
               }
 
               #ifndef exprtk_disable_enhanced_features
               if (details::is_sf3ext_node(branch[0]))
               {
                  expression_node_ptr result = error_node();
 
                  const bool synthesis_result =
                     synthesize_sf4ext_expression::template compile_left<ctype>
                        (expr_gen, c, operation, branch[0], result);
 
                  if (synthesis_result)
                  {
                     free_node(*expr_gen.node_allocator_, branch[0]);
 
                     return result;
                  }
               }
               #endif
 
               switch (operation)
               {
                  #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);                                                 \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_cocob_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               expression_node_ptr result = error_node();
 
               // (cob) o c --> cob
               if (details::is_cob_node(branch[0]))
               {
                  details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[0]);
 
                  const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
 
                  if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return expr_gen(T(0));
                  }
                  else if (std::equal_to<T>()(T(0),c) && (details::e_div == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return expr_gen(T(std::numeric_limits<T>::quiet_NaN()));
                  }
                  else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return branch[0];
                  }
                  else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return branch[0];
                  }
                  else if (std::equal_to<T>()(T(1),c) && (details::e_div == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return branch[0];
                  }
 
                  const bool op_addsub = (details::e_add == cobnode->operation()) ||
                                         (details::e_sub == cobnode->operation()) ;
 
                  if (op_addsub)
                  {
                     switch (operation)
                     {
                        case details::e_add : cobnode->set_c(cobnode->c() + c); break;
                        case details::e_sub : cobnode->set_c(cobnode->c() - c); break;
                        default             : return error_node();
                     }
 
                     result = cobnode;
                  }
                  else if (details::e_mul == cobnode->operation())
                  {
                     switch (operation)
                     {
                        case details::e_mul : cobnode->set_c(cobnode->c() * c); break;
                        case details::e_div : cobnode->set_c(cobnode->c() / c); break;
                        default             : return error_node();
                     }
 
                     result = cobnode;
                  }
                  else if (details::e_div == cobnode->operation())
                  {
                     if (details::e_mul == operation)
                     {
                        cobnode->set_c(cobnode->c() * c);
                        result = cobnode;
                     }
                     else if (details::e_div == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                       (cobnode->c() / c, cobnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_, branch[0]);
                     }
                  }
 
                  if (result)
                  {
                     details::free_node(*expr_gen.node_allocator_,branch[1]);
                  }
               }
 
               // c o (cob) --> cob
               else if (details::is_cob_node(branch[1]))
               {
                  details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[1]);
 
                  const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value();
 
                  if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return expr_gen(T(0));
                  }
                  else if (std::equal_to<T>()(T(0),c) && (details::e_div == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
 
                     return expr_gen(T(0));
                  }
                  else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
 
                     return branch[1];
                  }
                  else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation))
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[0]);
 
                     return branch[1];
                  }
 
                  if (details::e_add == cobnode->operation())
                  {
                     if (details::e_add == operation)
                     {
                        cobnode->set_c(c + cobnode->c());
                        result = cobnode;
                     }
                     else if (details::e_sub == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
                                       (c - cobnode->c(), cobnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
                  else if (details::e_sub == cobnode->operation())
                  {
                     if (details::e_add == operation)
                     {
                        cobnode->set_c(c + cobnode->c());
                        result = cobnode;
                     }
                     else if (details::e_sub == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::add_op<Type> > >
                                       (c - cobnode->c(), cobnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
                  else if (details::e_mul == cobnode->operation())
                  {
                     if (details::e_mul == operation)
                     {
                        cobnode->set_c(c * cobnode->c());
                        result = cobnode;
                     }
                     else if (details::e_div == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                       (c / cobnode->c(), cobnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
                  else if (details::e_div == cobnode->operation())
                  {
                     if (details::e_mul == operation)
                     {
                        cobnode->set_c(c * cobnode->c());
                        result = cobnode;
                     }
                     else if (details::e_div == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::mul_op<Type> > >
                                       (c / cobnode->c(), cobnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
 
                  if (result)
                  {
                     details::free_node(*expr_gen.node_allocator_,branch[0]);
                  }
               }
 
               return result;
            }
         };
 
         struct synthesize_coboc_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               expression_node_ptr result = error_node();
 
               // (boc) o c --> boc
               if (details::is_boc_node(branch[0]))
               {
                  details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]);
 
                  const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
 
                  if (details::e_add == bocnode->operation())
                  {
                     switch (operation)
                     {
                        case details::e_add : bocnode->set_c(bocnode->c() + c); break;
                        case details::e_sub : bocnode->set_c(bocnode->c() - c); break;
                        default             : return error_node();
                     }
 
                     result = bocnode;
                  }
                  else if (details::e_mul == bocnode->operation())
                  {
                     switch (operation)
                     {
                        case details::e_mul : bocnode->set_c(bocnode->c() * c); break;
                        case details::e_div : bocnode->set_c(bocnode->c() / c); break;
                        default             : return error_node();
                     }
 
                     result = bocnode;
                  }
                  else if (details::e_sub == bocnode->operation())
                  {
                     if (details::e_add == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::boc_node<Type,details::add_op<Type> > >
                                       (bocnode->move_branch(0), c - bocnode->c());
 
                        details::free_node(*expr_gen.node_allocator_,branch[0]);
                     }
                     else if (details::e_sub == operation)
                     {
                        bocnode->set_c(bocnode->c() + c);
                        result = bocnode;
                     }
                  }
                  else if (details::e_div == bocnode->operation())
                  {
                     switch (operation)
                     {
                        case details::e_div : bocnode->set_c(bocnode->c() * c); break;
                        case details::e_mul : bocnode->set_c(bocnode->c() / c); break;
                        default             : return error_node();
                     }
 
                     result = bocnode;
                  }
 
                  if (result)
                  {
                     details::free_node(*expr_gen.node_allocator_, branch[1]);
                  }
               }
 
               // c o (boc) --> boc
               else if (details::is_boc_node(branch[1]))
               {
                  details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[1]);
 
                  const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value();
 
                  if (details::e_add == bocnode->operation())
                  {
                     if (details::e_add == operation)
                     {
                        bocnode->set_c(c + bocnode->c());
                        result = bocnode;
                     }
                     else if (details::e_sub == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
                                       (c - bocnode->c(), bocnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
                  else if (details::e_sub == bocnode->operation())
                  {
                     if (details::e_add == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::boc_node<Type,details::add_op<Type> > >
                                       (bocnode->move_branch(0), c - bocnode->c());
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                     else if (details::e_sub == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
                                       (c + bocnode->c(), bocnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
                  else if (details::e_mul == bocnode->operation())
                  {
                     if (details::e_mul == operation)
                     {
                        bocnode->set_c(c * bocnode->c());
                        result = bocnode;
                     }
                     else if (details::e_div == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                       (c / bocnode->c(), bocnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
                  else if (details::e_div == bocnode->operation())
                  {
                     if (details::e_mul == operation)
                     {
                        bocnode->set_c(bocnode->c() / c);
                        result = bocnode;
                     }
                     else if (details::e_div == operation)
                     {
                        result = expr_gen.node_allocator_->
                                    template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                       (c * bocnode->c(), bocnode->move_branch(0));
 
                        details::free_node(*expr_gen.node_allocator_,branch[1]);
                     }
                  }
 
                  if (result)
                  {
                     details::free_node(*expr_gen.node_allocator_,branch[0]);
                  }
               }
 
               return result;
            }
         };
 
         #ifndef exprtk_disable_enhanced_features
         inline bool synthesize_expression(const details::operator_type& operation,
                                           expression_node_ptr (&branch)[2],
                                           expression_node_ptr& result)
         {
            result = error_node();
 
            if (!operation_optimisable(operation))
               return false;
 
            const std::string node_id = branch_to_id(branch);
 
            const typename synthesize_map_t::iterator itr = synthesize_map_.find(node_id);
 
            if (synthesize_map_.end() != itr)
            {
               result = itr->second((*this), operation, branch);
 
               return true;
            }
            else
               return false;
         }
 
         struct synthesize_vov_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
 
               switch (operation)
               {
                  #define case_stmt(op0, op1)                                                      \
                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rr<typename details::vov_node<Type,op1<Type> > > \
                                   (v1, v2);                                                       \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_cov_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type  c = static_cast<details::literal_node<Type>*> (branch[0])->value();
               const Type& v = static_cast<details::variable_node<Type>*>(branch[1])->ref  ();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation))
                  return expr_gen(T(0));
               else if (std::equal_to<T>()(T(0),c) && (details::e_div == operation))
                  return expr_gen(T(0));
               else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation))
                  return static_cast<details::variable_node<Type>*>(branch[1]);
               else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation))
                  return static_cast<details::variable_node<Type>*>(branch[1]);
 
               switch (operation)
               {
                  #define case_stmt(op0, op1)                                                      \
                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::cov_node<Type,op1<Type> > > \
                                   (c, v);                                                         \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_voc_expression
         {
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type& v = static_cast<details::variable_node<Type>*>(branch[0])->ref  ();
               const Type  c = static_cast<details::literal_node<Type>*> (branch[1])->value();
 
               details::free_node(*(expr_gen.node_allocator_), branch[1]);
 
               if (expr_gen.cardinal_pow_optimisable(operation,c))
               {
                  if (std::equal_to<T>()(T(1),c))
                     return branch[0];
                  else
                     return expr_gen.cardinal_pow_optimisation(v,c);
               }
               else if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation))
                  return expr_gen(T(0));
               else if (std::equal_to<T>()(T(0),c) && (details::e_div == operation))
                  return expr_gen(std::numeric_limits<T>::quiet_NaN());
               else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation))
                  return static_cast<details::variable_node<Type>*>(branch[0]);
               else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation))
                  return static_cast<details::variable_node<Type>*>(branch[0]);
               else if (std::equal_to<T>()(T(1),c) && (details::e_div == operation))
                  return static_cast<details::variable_node<Type>*>(branch[0]);
 
               switch (operation)
               {
                  #define case_stmt(op0, op1)                                                      \
                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::voc_node<Type,op1<Type> > > \
                                   (v, c);                                                         \
 
                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }
         };
 
         struct synthesize_sf3ext_expression
         {
            template <typename T0, typename T1, typename T2>
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& sf3opr,
                                                      T0 t0, T1 t1, T2 t2)
            {
               switch (sf3opr)
               {
                  #define case_stmt(op)                                                                              \
                  case details::e_sf##op : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,details::sf##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2);                                   \
 
                  case_stmt(00) case_stmt(01) case_stmt(02) case_stmt(03)
                  case_stmt(04) case_stmt(05) case_stmt(06) case_stmt(07)
                  case_stmt(08) case_stmt(09) case_stmt(10) case_stmt(11)
                  case_stmt(12) case_stmt(13) case_stmt(14) case_stmt(15)
                  case_stmt(16) case_stmt(17) case_stmt(18) case_stmt(19)
                  case_stmt(20) case_stmt(21) case_stmt(22) case_stmt(23)
                  case_stmt(24) case_stmt(25) case_stmt(26) case_stmt(27)
                  case_stmt(28) case_stmt(29) case_stmt(30)
                  #undef case_stmt
                  default : return error_node();
               }
            }
 
            template <typename T0, typename T1, typename T2>
            static inline bool compile(expression_generator<Type>& expr_gen, const std::string& id,
                                       T0 t0, T1 t1, T2 t2,
                                       expression_node_ptr& result)
            {
               details::operator_type sf3opr;
 
               if (!expr_gen.sf3_optimisable(id,sf3opr))
                  return false;
               else
                  result = synthesize_sf3ext_expression::template process<T0, T1, T2>
                              (expr_gen, sf3opr, t0, t1, t2);
 
               return true;
            }
         };
 
         struct synthesize_sf4ext_expression
         {
            template <typename T0, typename T1, typename T2, typename T3>
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& sf4opr,
                                                      T0 t0, T1 t1, T2 t2, T3 t3)
            {
               switch (sf4opr)
               {
                  #define case_stmt0(op)                                                                                      \
                  case details::e_sf##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sf##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3);                                        \
 
                  #define case_stmt1(op)                                                                                             \
                  case details::e_sf4ext##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sfext##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3);                                               \
 
                  case_stmt0(48) case_stmt0(49) case_stmt0(50) case_stmt0(51)
                  case_stmt0(52) case_stmt0(53) case_stmt0(54) case_stmt0(55)
                  case_stmt0(56) case_stmt0(57) case_stmt0(58) case_stmt0(59)
                  case_stmt0(60) case_stmt0(61) case_stmt0(62) case_stmt0(63)
                  case_stmt0(64) case_stmt0(65) case_stmt0(66) case_stmt0(67)
                  case_stmt0(68) case_stmt0(69) case_stmt0(70) case_stmt0(71)
                  case_stmt0(72) case_stmt0(73) case_stmt0(74) case_stmt0(75)
                  case_stmt0(76) case_stmt0(77) case_stmt0(78) case_stmt0(79)
                  case_stmt0(80) case_stmt0(81) case_stmt0(82) case_stmt0(83)
 
                  case_stmt1(00) case_stmt1(01) case_stmt1(02) case_stmt1(03)
                  case_stmt1(04) case_stmt1(05) case_stmt1(06) case_stmt1(07)
                  case_stmt1(08) case_stmt1(09) case_stmt1(10) case_stmt1(11)
                  case_stmt1(12) case_stmt1(13) case_stmt1(14) case_stmt1(15)
                  case_stmt1(16) case_stmt1(17) case_stmt1(18) case_stmt1(19)
                  case_stmt1(20) case_stmt1(21) case_stmt1(22) case_stmt1(23)
                  case_stmt1(24) case_stmt1(25) case_stmt1(26) case_stmt1(27)
                  case_stmt1(28) case_stmt1(29) case_stmt1(30) case_stmt1(31)
                  case_stmt1(32) case_stmt1(33) case_stmt1(34) case_stmt1(35)
                  case_stmt1(36) case_stmt1(37) case_stmt1(38) case_stmt1(39)
                  case_stmt1(40) case_stmt1(41) case_stmt1(42) case_stmt1(43)
                  case_stmt1(44) case_stmt1(45) case_stmt1(46) case_stmt1(47)
                  case_stmt1(48) case_stmt1(49) case_stmt1(50) case_stmt1(51)
                  case_stmt1(52) case_stmt1(53) case_stmt1(54) case_stmt1(55)
                  case_stmt1(56) case_stmt1(57) case_stmt1(58) case_stmt1(59)
                  case_stmt1(60) case_stmt1(61)
 
                  #undef case_stmt0
                  #undef case_stmt1
                  default : return error_node();
               }
            }
 
            template <typename T0, typename T1, typename T2, typename T3>
            static inline bool compile(expression_generator<Type>& expr_gen, const std::string& id,
                                       T0 t0, T1 t1, T2 t2, T3 t3,
                                       expression_node_ptr& result)
            {
               details::operator_type sf4opr;
 
               if (!expr_gen.sf4_optimisable(id,sf4opr))
                  return false;
               else
                  result = synthesize_sf4ext_expression::template process<T0, T1, T2, T3>
                              (expr_gen, sf4opr, t0, t1, t2, t3);
 
               return true;
            }
 
            // T o (sf3ext)
            template <typename ExternalType>
            static inline bool compile_right(expression_generator<Type>& expr_gen,
                                             ExternalType t,
                                             const details::operator_type& operation,
                                             expression_node_ptr& sf3node,
                                             expression_node_ptr& result)
            {
               if (!details::is_sf3ext_node(sf3node))
                  return false;
 
               typedef details::T0oT1oT2_base_node<Type>* sf3ext_base_ptr;
 
               sf3ext_base_ptr n = static_cast<sf3ext_base_ptr>(sf3node);
               const std::string id = "t" + expr_gen.to_str(operation) + "(" + n->type_id() + ")";
 
               switch (n->type())
               {
                  case details::expression_node<Type>::e_covoc : return compile_right_impl
                                                                    <typename covoc_t::sf3_type_node,ExternalType, ctype, vtype, ctype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_covov : return compile_right_impl
                                                                    <typename covov_t::sf3_type_node,ExternalType, ctype, vtype, vtype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_vocov : return compile_right_impl
                                                                    <typename vocov_t::sf3_type_node,ExternalType, vtype, ctype, vtype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_vovoc : return compile_right_impl
                                                                    <typename vovoc_t::sf3_type_node,ExternalType, vtype, vtype, ctype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_vovov : return compile_right_impl
                                                                    <typename vovov_t::sf3_type_node,ExternalType, vtype, vtype, vtype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  default                                      : return false;
               }
            }
 
            // (sf3ext) o T
            template <typename ExternalType>
            static inline bool compile_left(expression_generator<Type>& expr_gen,
                                            ExternalType t,
                                            const details::operator_type& operation,
                                            expression_node_ptr& sf3node,
                                            expression_node_ptr& result)
            {
               if (!details::is_sf3ext_node(sf3node))
                  return false;
 
               typedef details::T0oT1oT2_base_node<Type>* sf3ext_base_ptr;
 
               sf3ext_base_ptr n = static_cast<sf3ext_base_ptr>(sf3node);
 
               const std::string id = "(" + n->type_id() + ")" + expr_gen.to_str(operation) + "t";
 
               switch (n->type())
               {
                  case details::expression_node<Type>::e_covoc : return compile_left_impl
                                                                    <typename covoc_t::sf3_type_node,ExternalType, ctype, vtype, ctype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_covov : return compile_left_impl
                                                                    <typename covov_t::sf3_type_node,ExternalType, ctype, vtype, vtype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_vocov : return compile_left_impl
                                                                    <typename vocov_t::sf3_type_node,ExternalType, vtype, ctype, vtype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_vovoc : return compile_left_impl
                                                                    <typename vovoc_t::sf3_type_node,ExternalType, vtype, vtype, ctype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  case details::expression_node<Type>::e_vovov : return compile_left_impl
                                                                    <typename vovov_t::sf3_type_node,ExternalType, vtype, vtype, vtype>
                                                                       (expr_gen, id, t, sf3node, result);
 
                  default                                      : return false;
               }
            }
 
            template <typename SF3TypeNode, typename ExternalType, typename T0, typename T1, typename T2>
            static inline bool compile_right_impl(expression_generator<Type>& expr_gen,
                                                  const std::string& id,
                                                  ExternalType t,
                                                  expression_node_ptr& node,
                                                  expression_node_ptr& result)
            {
               SF3TypeNode* n = dynamic_cast<SF3TypeNode*>(node);
 
               if (n)
               {
                  T0 t0 = n->t0();
                  T1 t1 = n->t1();
                  T2 t2 = n->t2();
 
                  return synthesize_sf4ext_expression::template compile<ExternalType, T0, T1, T2>
                            (expr_gen, id, t, t0, t1, t2, result);
               }
               else
                  return false;
            }
 
            template <typename SF3TypeNode, typename ExternalType, typename T0, typename T1, typename T2>
            static inline bool compile_left_impl(expression_generator<Type>& expr_gen,
                                                 const std::string& id,
                                                 ExternalType t,
                                                 expression_node_ptr& node,
                                                 expression_node_ptr& result)
            {
               SF3TypeNode* n = dynamic_cast<SF3TypeNode*>(node);
 
               if (n)
               {
                  T0 t0 = n->t0();
                  T1 t1 = n->t1();
                  T2 t2 = n->t2();
 
                  return synthesize_sf4ext_expression::template compile<T0, T1, T2, ExternalType>
                            (expr_gen, id, t0, t1, t2, t, result);
               }
               else
                  return false;
            }
         };
 
         struct synthesize_vovov_expression0
         {
            typedef typename vovov_t::type0 node_type;
            typedef typename vovov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 v1) o1 (v2)
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[0]);
               const Type& v0 = vov->v0();
               const Type& v1 = vov->v1();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = vov->operation();
               const details::operator_type o1 = operation;
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / v1) / v2 --> (vovov) v0 / (v1 * v2)
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, vtype>(expr_gen, "t/(t*t)", v0, v1, v2, result);
 
                     exprtk_debug(("(v0 / v1) / v2 --> (vovov) v0 / (v1 * v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, vtype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }
         };
 
         struct synthesize_vovov_expression1
         {
            typedef typename vovov_t::type1 node_type;
            typedef typename vovov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0) o0 (v1 o1 v2)
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vov->v0();
               const Type& v2 = vov->v1();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = vov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // v0 / (v1 / v2) --> (vovov) (v0 * v2) / v1
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, vtype>(expr_gen, "(t*t)/t", v0, v2, v1, result);
 
                     exprtk_debug(("v0 / (v1 / v2) --> (vovov) (v0 * v2) / v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, vtype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)";
            }
         };
 
         struct synthesize_vovoc_expression0
         {
            typedef typename vovoc_t::type0 node_type;
            typedef typename vovoc_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 v1) o1 (c)
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[0]);
               const Type& v0 = vov->v0();
               const Type& v1 = vov->v1();
               const Type   c = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = vov->operation();
               const details::operator_type o1 = operation;
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / v1) / c --> (vovoc) v0 / (v1 * c)
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, ctype>(expr_gen, "t/(t*t)", v0, v1, c, result);
 
                     exprtk_debug(("(v0 / v1) / c --> (vovoc) v0 / (v1 * c)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, vtype, ctype>
                     (expr_gen, id(expr_gen, o0, o1), v0, v1, c, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }
         };
 
         struct synthesize_vovoc_expression1
         {
            typedef typename vovoc_t::type1 node_type;
            typedef typename vovoc_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0) o0 (v1 o1 c)
               const details::voc_base_node<Type>* voc = static_cast<const details::voc_base_node<Type>*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = voc->v();
               const Type   c = voc->c();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = voc->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // v0 / (v1 / c) --> (vocov) (v0 * c) / v1
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, ctype, vtype>(expr_gen, "(t*t)/t", v0, c, v1, result);
 
                     exprtk_debug(("v0 / (v1 / c) --> (vocov) (v0 * c) / v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, vtype, ctype>
                     (expr_gen, id(expr_gen, o0, o1), v0, v1, c, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)";
            }
         };
 
         struct synthesize_vocov_expression0
         {
            typedef typename vocov_t::type0 node_type;
            typedef typename vocov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 c) o1 (v1)
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[0]);
               const Type& v0 = voc->v();
               const Type   c = voc->c();
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = voc->operation();
               const details::operator_type o1 = operation;
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / c) / v1 --> (vovoc) v0 / (v1 * c)
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, ctype>(expr_gen, "t/(t*t)", v0, v1, c, result);
 
                     exprtk_debug(("(v0 / c) / v1 --> (vovoc) v0 / (v1 * c)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, ctype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), v0, c, v1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }
         };
 
         struct synthesize_vocov_expression1
         {
            typedef typename vocov_t::type1 node_type;
            typedef typename vocov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0) o0 (c o1 v1)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type   c = cov->c();
               const Type& v1 = cov->v();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = cov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // v0 / (c / v1) --> (vovoc) (v0 * v1) / c
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, ctype>(expr_gen, "(t*t)/t", v0, v1, c, result);
 
                     exprtk_debug(("v0 / (c / v1) --> (vovoc) (v0 * v1) / c\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, ctype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), v0, c, v1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)";
            }
         };
 
         struct synthesize_covov_expression0
         {
            typedef typename covov_t::type0 node_type;
            typedef typename covov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c o0 v0) o1 (v1)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const Type   c = cov->c();
               const Type& v0 = cov->v();
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = cov->operation();
               const details::operator_type o1 = operation;
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c / v0) / v1 --> (covov) c / (v0 * v1)
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", c, v0, v1, result);
 
                     exprtk_debug(("(c / v0) / v1 --> (covov) c / (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<ctype, vtype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), c, v0, v1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }
         };
 
         struct synthesize_covov_expression1
         {
            typedef typename covov_t::type1 node_type;
            typedef typename covov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c) o0 (v0 o1 v1)
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[1]);
               const Type   c = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vov->v0();
               const Type& v1 = vov->v1();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = vov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // c / (v0 / v1) --> (covov) (c * v1) / v0
                  if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", c, v1, v0, result);
 
                     exprtk_debug(("c / (v0 / v1) --> (covov) (c * v1) / v0\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<ctype, vtype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), c, v0, v1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)";
            }
         };
 
         struct synthesize_covoc_expression0
         {
            typedef typename covoc_t::type0 node_type;
            typedef typename covoc_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c0 o0 v) o1 (c1)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const Type  c0 = cov->c();
               const Type&  v = cov->v();
               const Type  c1 = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = cov->operation();
               const details::operator_type o1 = operation;
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0 + v) + c1 --> (cov) (c0 + c1) + v
                  if ((details::e_add == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(c0 + v) + c1 --> (cov) (c0 + c1) + v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1, v);
                  }
                  // (c0 + v) - c1 --> (cov) (c0 - c1) + v
                  else if ((details::e_add == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(c0 + v) - c1 --> (cov) (c0 - c1) + v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1, v);
                  }
                  // (c0 - v) + c1 --> (cov) (c0 + c1) - v
                  else if ((details::e_sub == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(c0 - v) + c1 --> (cov) (c0 + c1) - v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1, v);
                  }
                  // (c0 - v) - c1 --> (cov) (c0 - c1) - v
                  else if ((details::e_sub == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(c0 - v) - c1 --> (cov) (c0 - c1) - v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1, v);
                  }
                  // (c0 * v) * c1 --> (cov) (c0 * c1) * v
                  else if ((details::e_mul == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(c0 * v) * c1 --> (cov) (c0 * c1) * v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1, v);
                  }
                  // (c0 * v) / c1 --> (cov) (c0 / c1) * v
                  else if ((details::e_mul == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(c0 * v) / c1 --> (cov) (c0 / c1) * v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1, v);
                  }
                  // (c0 / v) * c1 --> (cov) (c0 * c1) / v
                  else if ((details::e_div == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(c0 / v) * c1 --> (cov) (c0 * c1) / v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1, v);
                  }
                  // (c0 / v) / c1 --> (cov) (c0 / c1) / v
                  else if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(c0 / v) / c1 --> (cov) (c0 / c1) / v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1, v);
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<ctype, vtype, ctype>
                     (expr_gen, id(expr_gen, o0, o1), c0, v, c1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, v, c1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }
         };
 
         struct synthesize_covoc_expression1
         {
            typedef typename covoc_t::type1 node_type;
            typedef typename covoc_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c0) o0 (v o1 c1)
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[1]);
               const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type&  v = voc->v();
               const Type  c1 = voc->c();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = voc->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0) + (v + c1) --> (cov) (c0 + c1) + v
                  if ((details::e_add == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(c0) + (v + c1) --> (cov) (c0 + c1) + v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1, v);
                  }
                  // (c0) + (v - c1) --> (cov) (c0 - c1) + v
                  else if ((details::e_add == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(c0) + (v - c1) --> (cov) (c0 - c1) + v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1, v);
                  }
                  // (c0) - (v + c1) --> (cov) (c0 - c1) - v
                  else if ((details::e_sub == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(c0) - (v + c1) --> (cov) (c0 - c1) - v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1, v);
                  }
                  // (c0) - (v - c1) --> (cov) (c0 + c1) - v
                  else if ((details::e_sub == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(c0) - (v - c1) --> (cov) (c0 + c1) - v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1, v);
                  }
                  // (c0) * (v * c1) --> (voc) v * (c0 * c1)
                  else if ((details::e_mul == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(c0) * (v * c1) --> (voc) v * (c0 * c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1, v);
                  }
                  // (c0) * (v / c1) --> (cov) (c0 / c1) * v
                  else if ((details::e_mul == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(c0) * (v / c1) --> (cov) (c0 / c1) * v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1, v);
                  }
                  // (c0) / (v * c1) --> (cov) (c0 / c1) / v
                  else if ((details::e_div == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(c0) / (v * c1) --> (cov) (c0 / c1) / v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1, v);
                  }
                  // (c0) / (v / c1) --> (cov) (c0 * c1) / v
                  else if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(c0) / (v / c1) --> (cov) (c0 * c1) / v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1, v);
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<ctype, vtype, ctype>
                     (expr_gen, id(expr_gen, o0, o1), c0, v, c1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, v, c1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)";
            }
         };
 
         struct synthesize_cocov_expression0
         {
            typedef typename cocov_t::type0 node_type;
            static inline expression_node_ptr process(expression_generator<Type>&,
                                                      const details::operator_type&,
                                                      expression_node_ptr (&)[2])
            {
               // (c0 o0 c1) o1 (v) - Not possible.
               return error_node();
            }
         };
 
         struct synthesize_cocov_expression1
         {
            typedef typename cocov_t::type1 node_type;
            typedef typename cocov_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c0) o0 (c1 o1 v)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type  c1 = cov->c();
               const Type&  v = cov->v();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = cov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0) + (c1 + v) --> (cov) (c0 + c1) + v
                  if ((details::e_add == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(c0) + (c1 + v) --> (cov) (c0 + c1) + v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1, v);
                  }
                  // (c0) + (c1 - v) --> (cov) (c0 + c1) - v
                  else if ((details::e_add == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(c0) + (c1 - v) --> (cov) (c0 + c1) - v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1, v);
                  }
                  // (c0) - (c1 + v) --> (cov) (c0 - c1) - v
                  else if ((details::e_sub == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(c0) - (c1 + v) --> (cov) (c0 - c1) - v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1, v);
                  }
                  // (c0) - (c1 - v) --> (cov) (c0 - c1) + v
                  else if ((details::e_sub == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(c0) - (c1 - v) --> (cov) (c0 - c1) + v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1, v);
                  }
                  // (c0) * (c1 * v) --> (cov) (c0 * c1) * v
                  else if ((details::e_mul == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(c0) * (c1 * v) --> (cov) (c0 * c1) * v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1, v);
                  }
                  // (c0) * (c1 / v) --> (cov) (c0 * c1) / v
                  else if ((details::e_mul == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(c0) * (c1 / v) --> (cov) (c0 * c1) / v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1, v);
                  }
                  // (c0) / (c1 * v) --> (cov) (c0 / c1) / v
                  else if ((details::e_div == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(c0) / (c1 * v) --> (cov) (c0 / c1) / v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1, v);
                  }
                  // (c0) / (c1 / v) --> (cov) (c0 / c1) * v
                  else if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(c0) / (c1 / v) --> (cov) (c0 / c1) * v\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1, v);
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<ctype, ctype, vtype>
                     (expr_gen, id(expr_gen, o0, o1), c0, c1, v, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, c1, v, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)";
            }
         };
 
         struct synthesize_vococ_expression0
         {
            typedef typename vococ_t::type0 node_type;
            typedef typename vococ_t::sf3_type sf3_type;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v o0 c0) o1 (c1)
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[0]);
               const Type&  v = voc->v();
               const Type& c0 = voc->c();
               const Type& c1 = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = voc->operation();
               const details::operator_type o1 = operation;
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v + c0) + c1 --> (voc) v + (c0 + c1)
                  if ((details::e_add == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(v + c0) + c1 --> (voc) v + (c0 + c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v, c0 + c1);
                  }
                  // (v + c0) - c1 --> (voc) v + (c0 - c1)
                  else if ((details::e_add == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(v + c0) - c1 --> (voc) v + (c0 - c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v, c0 - c1);
                  }
                  // (v - c0) + c1 --> (voc) v - (c0 + c1)
                  else if ((details::e_sub == o0) && (details::e_add == o1))
                  {
                     exprtk_debug(("(v - c0) + c1 --> (voc) v - (c0 + c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v, c1 - c0);
                  }
                  // (v - c0) - c1 --> (voc) v - (c0 + c1)
                  else if ((details::e_sub == o0) && (details::e_sub == o1))
                  {
                     exprtk_debug(("(v - c0) - c1 --> (voc) v - (c0 + c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::sub_op<Type> > >(v, c0 + c1);
                  }
                  // (v * c0) * c1 --> (voc) v * (c0 * c1)
                  else if ((details::e_mul == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(v * c0) * c1 --> (voc) v * (c0 * c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v, c0 * c1);
                  }
                  // (v * c0) / c1 --> (voc) v * (c0 / c1)
                  else if ((details::e_mul == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(v * c0) / c1 --> (voc) v * (c0 / c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v, c0 / c1);
                  }
                  // (v / c0) * c1 --> (voc) v * (c1 / c0)
                  else if ((details::e_div == o0) && (details::e_mul == o1))
                  {
                     exprtk_debug(("(v / c0) * c1 --> (voc) v * (c1 / c0)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v, c1 / c0);
                  }
                  // (v / c0) / c1 --> (voc) v / (c0 * c1)
                  else if ((details::e_div == o0) && (details::e_div == o1))
                  {
                     exprtk_debug(("(v / c0) / c1 --> (voc) v / (c0 * c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::div_op<Type> > >(v, c0 * c1);
                  }
                  // (v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1)
                  else if ((details::e_pow == o0) && (details::e_pow == o1))
                  {
                     exprtk_debug(("(v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1)\n"));
 
                     return expr_gen.node_allocator_->
                               template allocate_rc<typename details::voc_node<Type,details::pow_op<Type> > >(v, c0 * c1);
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf3ext_expression::template compile<vtype, ctype, ctype>
                     (expr_gen, id(expr_gen, o0, o1), v, c0, c1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v, c0, c1, f0, f1);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }
         };
 
         struct synthesize_vococ_expression1
         {
            typedef typename vococ_t::type0 node_type;
 
            static inline expression_node_ptr process(expression_generator<Type>&,
                                                      const details::operator_type&,
                                                      expression_node_ptr (&)[2])
            {
               // (v) o0 (c0 o1 c1) - Not possible.
               exprtk_debug(("(v) o0 (c0 o1 c1) - Not possible.\n"));
               return error_node();
            }
         };
 
         struct synthesize_vovovov_expression0
         {
            typedef typename vovovov_t::type0 node_type;
            typedef typename vovovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 v1) o1 (v2 o2 v3)
               const details::vov_base_node<Type>* vov0 = static_cast<details::vov_base_node<Type>*>(branch[0]);
               const details::vov_base_node<Type>* vov1 = static_cast<details::vov_base_node<Type>*>(branch[1]);
               const Type& v0 = vov0->v0();
               const Type& v1 = vov0->v1();
               const Type& v2 = vov1->v0();
               const Type& v3 = vov1->v1();
               const details::operator_type o0 = vov0->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = vov1->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / v1) * (v2 / v3) --> (vovovov) (v0 * v2) / (v1 * v3)
                  if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, vtype>(expr_gen, "(t*t)/(t*t)", v0, v2, v1, v3, result);
 
                     exprtk_debug(("(v0 / v1) * (v2 / v3) --> (vovovov) (v0 * v2) / (v1 * v3)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / v1) / (v2 / v3) --> (vovovov) (v0 * v3) / (v1 * v2)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, vtype>(expr_gen, "(t*t)/(t*t)", v0, v3, v1, v2, result);
 
                     exprtk_debug(("(v0 / v1) / (v2 / v3) --> (vovovov) (v0 * v3) / (v1 * v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 + v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)
                  else if ((details::e_add == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, vtype>(expr_gen, "(t+t)*(t/t)", v0, v1, v3, v2, result);
 
                     exprtk_debug(("(v0 + v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 - v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)
                  else if ((details::e_sub == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, vtype>(expr_gen, "(t-t)*(t/t)", v0, v1, v3, v2, result);
 
                     exprtk_debug(("(v0 - v1) / (v2 / v3) --> (vovovov) (v0 - v1) * (v3 / v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * v1) / (v2 / v3) --> (vovovov) ((v0 * v1) * v3) / v2
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, vtype>(expr_gen, "((t*t)*t)/t", v0, v1, v3, v2, result);
 
                     exprtk_debug(("(v0 * v1) / (v2 / v3) --> (vovovov) ((v0 * v1) * v3) / v2\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vovovoc_expression0
         {
            typedef typename vovovoc_t::type0 node_type;
            typedef typename vovovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 v1) o1 (v2 o2 c)
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[0]);
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[1]);
               const Type& v0 = vov->v0();
               const Type& v1 = vov->v1();
               const Type& v2 = voc->v ();
               const Type   c = voc->c ();
               const details::operator_type o0 = vov->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = voc->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / v1) * (v2 / c) --> (vovovoc) (v0 * v2) / (v1 * c)
                  if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, ctype>(expr_gen, "(t*t)/(t*t)", v0, v2, v1, c, result);
 
                     exprtk_debug(("(v0 / v1) * (v2 / c) --> (vovovoc) (v0 * v2) / (v1 * c)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / v1) / (v2 / c) --> (vocovov) (v0 * c) / (v1 * v2)
                  if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, ctype, vtype, vtype>(expr_gen, "(t*t)/(t*t)", v0, c, v1, v2, result);
 
                     exprtk_debug(("(v0 / v1) / (v2 / c) --> (vocovov) (v0 * c) / (v1 * v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vovocov_expression0
         {
            typedef typename vovocov_t::type0 node_type;
            typedef typename vovocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 v1) o1 (c o2 v2)
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[0]);
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type& v0 = vov->v0();
               const Type& v1 = vov->v1();
               const Type& v2 = cov->v ();
               const Type   c = cov->c ();
               const details::operator_type o0 = vov->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = cov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / v1) * (c / v2) --> (vocovov) (v0 * c) / (v1 * v2)
                  if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, ctype, vtype, vtype>(expr_gen, "(t*t)/(t*t)", v0, c, v1, v2, result);
 
                     exprtk_debug(("(v0 / v1) * (c / v2) --> (vocovov) (v0 * c) / (v1 * v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / v1) / (c / v2) --> (vovovoc) (v0 * v2) / (v1 * c)
                  if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, vtype, ctype>(expr_gen, "(t*t)/(t*t)", v0, v2, v1, c, result);
 
                     exprtk_debug(("(v0 / v1) / (c / v2) --> (vovovoc) (v0 * v2) / (v1 * c)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vocovov_expression0
         {
            typedef typename vocovov_t::type0 node_type;
            typedef typename vocovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 c) o1 (v1 o2 v2)
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[0]);
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[1]);
               const Type   c = voc->c ();
               const Type& v0 = voc->v ();
               const Type& v1 = vov->v0();
               const Type& v2 = vov->v1();
               const details::operator_type o0 = voc->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = vov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 / c) * (v1 / v2) --> (vovocov) (v0 * v1) / (c * v2)
                  if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, ctype, vtype>(expr_gen, "(t*t)/(t*t)", v0, v1, c, v2, result);
 
                     exprtk_debug(("(v0 / c) * (v1 / v2) --> (vovocov) (v0 * v1) / (c * v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c) / (v1 / v2) --> (vovocov) (v0 * v2) / (c * v1)
                  if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, vtype, ctype, vtype>(expr_gen, "(t*t)/(t*t)", v0, v2, c, v1, result);
 
                     exprtk_debug(("(v0 / c) / (v1 / v2) --> (vovocov) (v0 * v2) / (c * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_covovov_expression0
         {
            typedef typename covovov_t::type0 node_type;
            typedef typename covovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c o0 v0) o1 (v1 o2 v2)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const details::vov_base_node<Type>* vov = static_cast<details::vov_base_node<Type>*>(branch[1]);
               const Type   c = cov->c ();
               const Type& v0 = cov->v ();
               const Type& v1 = vov->v0();
               const Type& v2 = vov->v1();
               const details::operator_type o0 = cov->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = vov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c / v0) * (v1 / v2) --> (covovov) (c * v1) / (v0 * v2)
                  if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<ctype, vtype, vtype, vtype>(expr_gen, "(t*t)/(t*t)", c, v1, v0, v2, result);
 
                     exprtk_debug(("(c / v0) * (v1 / v2) --> (covovov) (c * v1) / (v0 * v2)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c / v0) / (v1 / v2) --> (covovov) (c * v2) / (v0 * v1)
                  if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<ctype, vtype, vtype, vtype>(expr_gen, "(t*t)/(t*t)", c, v2, v0, v1, result);
 
                     exprtk_debug(("(c / v0) / (v1 / v2) --> (covovov) (c * v2) / (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_covocov_expression0
         {
            typedef typename covocov_t::type0 node_type;
            typedef typename covocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c0 o0 v0) o1 (c1 o2 v1)
               const details::cov_base_node<Type>* cov0 = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const details::cov_base_node<Type>* cov1 = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type  c0 = cov0->c();
               const Type& v0 = cov0->v();
               const Type  c1 = cov1->c();
               const Type& v1 = cov1->v();
               const details::operator_type o0 = cov0->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = cov1->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0 + v0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1
                  if ((details::e_add == o0) && (details::e_add == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)+t", (c0 + c1), v0, v1, result);
 
                     exprtk_debug(("(c0 + v0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 + v0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1
                  else if ((details::e_add == o0) && (details::e_sub == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c0 - c1), v0, v1, result);
 
                     exprtk_debug(("(c0 + v0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 - v0) - (c1 - v1) --> (covov) (c0 - c1) - v0 + v1
                  else if ((details::e_sub == o0) && (details::e_sub == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t-t)+t", (c0 - c1), v0, v1, result);
 
                     exprtk_debug(("(c0 - v0) - (c1 - v1) --> (covov) (c0 - c1) - v0 + v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1
                  else if ((details::e_mul == o0) && (details::e_mul == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(c0 * v0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(c0 * v0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) * (c1 / v1) --> (covov) (c0 * c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(c0 / v0) * (c1 / v1) --> (covov) (c0 * c1) / (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (c1 / v1) --> (covov) ((c0 / c1) * v1) / v0
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v1, v0, result);
 
                     exprtk_debug(("(c0 / v0) / (c1 / v1) --> (covov) ((c0 / c1) * v1) / v0\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t*(t*t)", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(c0 * v0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (c1 * v1) --> (covov) (c0 / c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(c0 / v0) / (c1 * v1) --> (covov) (c0 / c1) / (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c * v0) +/- (c * v1) --> (covov) c * (v0 +/- v1)
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_mul == o0)      &&
                            (details::e_mul == o2)      &&
                            (
                              (details::e_add == o1) ||
                              (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;
 
                     switch (o1)
                     {
                        case details::e_add : specfunc = "t*(t+t)"; break;
                        case details::e_sub : specfunc = "t*(t-t)"; break;
                        default             : return error_node();
                     }
 
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);
 
                     exprtk_debug(("(c * v0) +/- (c * v1) --> (covov) c * (v0 +/- v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vocovoc_expression0
         {
            typedef typename vocovoc_t::type0 node_type;
            typedef typename vocovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 c0) o1 (v1 o2 c1)
               const details::voc_base_node<Type>* voc0 = static_cast<details::voc_base_node<Type>*>(branch[0]);
               const details::voc_base_node<Type>* voc1 = static_cast<details::voc_base_node<Type>*>(branch[1]);
               const Type  c0 = voc0->c();
               const Type& v0 = voc0->v();
               const Type  c1 = voc1->c();
               const Type& v1 = voc1->v();
               const details::operator_type o0 = voc0->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = voc1->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 + c0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1
                  if ((details::e_add == o0) && (details::e_add == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)+t", (c0 + c1), v0, v1, result);
 
                     exprtk_debug(("(v0 + c0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 + c0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1
                  else if ((details::e_add == o0) && (details::e_sub == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c0 - c1), v0, v1, result);
 
                     exprtk_debug(("(v0 + c0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 - c0) - (v1 - c1) --> (covov) (c1 - c0) + v0 - v1
                  else if ((details::e_sub == o0) && (details::e_sub == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c1 - c0), v0, v1, result);
 
                     exprtk_debug(("(v0 - c0) - (v1 - c1) --> (covov) (c1 - c0) + v0 - v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1
                  else if ((details::e_mul == o0) && (details::e_mul == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(v0 * c0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(v0 * c0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) * (v1 / c1) --> (covov) (1 / (c0 * c1)) * v0 * v1
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", Type(1) / (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(v0 / c0) * (v1 / c1) --> (covov) (1 / (c0 * c1)) * v0 * v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) / (v1 / c1) --> (covov) ((c1 / c0) * v0) / v1
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c1 / c0), v0, v1, result);
 
                     exprtk_debug(("(v0 / c0) / (v1 / c1) --> (covov) ((c1 / c0) * v0) / v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t*(t/t)", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(v0 * c0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) / (v1 * c1) --> (covov) (1 / (c0 * c1)) * v0 / v1
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t*(t/t)", Type(1) / (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(v0 / c0) / (v1 * c1) --> (covov) (1 / (c0 * c1)) * v0 / v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) * (v1 + c1) --> (vocovoc) (v0 * (1 / c0)) * (v1 + c1)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, ctype, vtype, ctype>(expr_gen, "(t*t)*(t+t)", v0, T(1) / c0, v1, c1, result);
 
                     exprtk_debug(("(v0 / c0) * (v1 + c1) --> (vocovoc) (v0 * (1 / c0)) * (v1 + c1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) * (v1 - c1) --> (vocovoc) (v0 * (1 / c0)) * (v1 - c1)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf4ext_expression::
                           template compile<vtype, ctype, vtype, ctype>(expr_gen, "(t*t)*(t-t)", v0, T(1) / c0, v1, c1, result);
 
                     exprtk_debug(("(v0 / c0) * (v1 - c1) --> (vocovoc) (v0 * (1 / c0)) * (v1 - c1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c) +/- (v1 * c) --> (covov) c * (v0 +/- v1)
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_mul == o0)      &&
                            (details::e_mul == o2)      &&
                            (
                              (details::e_add == o1) ||
                              (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;
 
                     switch (o1)
                     {
                        case details::e_add : specfunc = "t*(t+t)"; break;
                        case details::e_sub : specfunc = "t*(t-t)"; break;
                        default             : return error_node();
                     }
 
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);
 
                     exprtk_debug(("(v0 * c) +/- (v1 * c) --> (covov) c * (v0 +/- v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c) +/- (v1 / c) --> (vovoc) (v0 +/- v1) / c
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_div == o0)      &&
                            (details::e_div == o2)      &&
                            (
                              (details::e_add == o1) ||
                              (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;
 
                     switch (o1)
                     {
                        case details::e_add : specfunc = "(t+t)/t"; break;
                        case details::e_sub : specfunc = "(t-t)/t"; break;
                        default             : return error_node();
                     }
 
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, ctype>(expr_gen, specfunc, v0, v1, c0, result);
 
                     exprtk_debug(("(v0 / c) +/- (v1 / c) --> (vovoc) (v0 +/- v1) / c\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_covovoc_expression0
         {
            typedef typename covovoc_t::type0 node_type;
            typedef typename covovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (c0 o0 v0) o1 (v1 o2 c1)
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[0]);
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[1]);
               const Type  c0 = cov->c();
               const Type& v0 = cov->v();
               const Type  c1 = voc->c();
               const Type& v1 = voc->v();
               const details::operator_type o0 = cov->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = voc->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (c0 + v0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1
                  if ((details::e_add == o0) && (details::e_add == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)+t", (c0 + c1), v0, v1, result);
 
                     exprtk_debug(("(c0 + v0) + (v1 + c1) --> (covov) (c0 + c1) + v0 + v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 + v0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1
                  else if ((details::e_add == o0) && (details::e_sub == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c0 - c1), v0, v1, result);
 
                     exprtk_debug(("(c0 + v0) - (v1 + c1) --> (covov) (c0 - c1) + v0 - v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 - v0) - (v1 - c1) --> (covov) (c0 + c1) - v0 - v1
                  else if ((details::e_sub == o0) && (details::e_sub == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t-(t+t)", (c0 + c1), v0, v1, result);
 
                     exprtk_debug(("(c0 - v0) - (v1 - c1) --> (covov) (c0 + c1) - v0 - v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1
                  else if ((details::e_mul == o0) && (details::e_mul == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(c0 * v0) * (v1 * c1) --> (covov) (c0 * c1) * v0 * v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(c0 * v0) / (v1 * c1) --> (covov) (c0 / c1) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) * (v1 / c1) --> (covov) (c0 / c1) * (v1 / v0)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t*(t/t)", (c0 / c1), v1, v0, result);
 
                     exprtk_debug(("(c0 / v0) * (v1 / c1) --> (covov) (c0 / c1) * (v1 / v0)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (v1 / c1) --> (covov) (c0 * c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(c0 / v0) / (v1 / c1) --> (covov) (c0 * c1) / (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 * v0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(c0 * v0) / (v1 / c1) --> (covov) (c0 * c1) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c0 / v0) / (v1 * c1) --> (covov) (c0 / c1) / (v0 * v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "t/(t*t)", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(c0 / v0) / (v1 * c1) --> (covov) (c0 / c1) / (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (c * v0) +/- (v1 * c) --> (covov) c * (v0 +/- v1)
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_mul == o0)      &&
                            (details::e_mul == o2)      &&
                            (
                              (details::e_add == o1) ||
                              (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;
 
                     switch (o1)
                     {
                        case details::e_add : specfunc = "t*(t+t)"; break;
                        case details::e_sub : specfunc = "t*(t-t)"; break;
                        default             : return error_node();
                     }
 
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);
 
                     exprtk_debug(("(c * v0) +/- (v1 * c) --> (covov) c * (v0 +/- v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vococov_expression0
         {
            typedef typename vococov_t::type0 node_type;
            typedef typename vococov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 c0) o1 (c1 o2 v1)
               const details::voc_base_node<Type>* voc = static_cast<details::voc_base_node<Type>*>(branch[0]);
               const details::cov_base_node<Type>* cov = static_cast<details::cov_base_node<Type>*>(branch[1]);
               const Type  c0 = voc->c();
               const Type& v0 = voc->v();
               const Type  c1 = cov->c();
               const Type& v1 = cov->v();
               const details::operator_type o0 = voc->operation();
               const details::operator_type o1 = operation;
               const details::operator_type o2 = cov->operation();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               if (expr_gen.parser_->settings_.strength_reduction_enabled())
               {
                  // (v0 + c0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1
                  if ((details::e_add == o0) && (details::e_add == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)+t", (c0 + c1), v0, v1, result);
 
                     exprtk_debug(("(v0 + c0) + (c1 + v1) --> (covov) (c0 + c1) + v0 + v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 + c0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1
                  else if ((details::e_add == o0) && (details::e_sub == o1) && (details::e_add == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t+t)-t", (c0 - c1), v0, v1, result);
 
                     exprtk_debug(("(v0 + c0) - (c1 + v1) --> (covov) (c0 - c1) + v0 - v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 - c0) - (c1 - v1) --> (vovoc) v0 + v1 - (c1 + c0)
                  else if ((details::e_sub == o0) && (details::e_sub == o1) && (details::e_sub == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, ctype>(expr_gen, "(t+t)-t", v0, v1, (c1 + c0), result);
 
                     exprtk_debug(("(v0 - c0) - (c1 - v1) --> (vovoc) v0 + v1 - (c1 + c0)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1
                  else if ((details::e_mul == o0) && (details::e_mul == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(v0 * c0) * (c1 * v1) --> (covov) (c0 * c1) * v0 * v1\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 * v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(v0 * c0) / (c1 * v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) * (c1 / v1) --> (covov) (c1 / c0) * (v0 / v1)
                  else if ((details::e_div == o0) && (details::e_mul == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", (c1 / c0), v0, v1, result);
 
                     exprtk_debug(("(v0 / c0) * (c1 / v1) --> (covov) (c1 / c0) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)
                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)*t", (c0 / c1), v0, v1, result);
 
                     exprtk_debug(("(v0 * c0) / (c1 / v1) --> (covov) (c0 / c1) * (v0 * v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) / (c1 * v1) --> (covov) (1 / (c0 * c1)) * (v0 / v1)
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_mul == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, "(t*t)/t", Type(1) / (c0 * c1), v0, v1, result);
 
                     exprtk_debug(("(v0 / c0) / (c1 * v1) --> (covov) (1 / (c0 * c1)) * (v0 / v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 / c0) / (c1 / v1) --> (vovoc) (v0 * v1) * (1 / (c0 * c1))
                  else if ((details::e_div == o0) && (details::e_div == o1) && (details::e_div == o2))
                  {
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<vtype, vtype, ctype>(expr_gen, "(t*t)*t", v0, v1, Type(1) / (c0 * c1), result);
 
                     exprtk_debug(("(v0 / c0) / (c1 / v1) --> (vovoc) (v0 * v1) * (1 / (c0 * c1))\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
                  // (v0 * c) +/- (c * v1) --> (covov) c * (v0 +/- v1)
                  else if (
                            (std::equal_to<T>()(c0,c1)) &&
                            (details::e_mul == o0)      &&
                            (details::e_mul == o2)      &&
                            (
                              (details::e_add == o1) || (details::e_sub == o1)
                            )
                          )
                  {
                     std::string specfunc;
 
                     switch (o1)
                     {
                        case details::e_add : specfunc = "t*(t+t)"; break;
                        case details::e_sub : specfunc = "t*(t-t)"; break;
                        default             : return error_node();
                     }
 
                     const bool synthesis_result =
                        synthesize_sf3ext_expression::
                           template compile<ctype, vtype, vtype>(expr_gen, specfunc, c0, v0, v1, result);
 
                     exprtk_debug(("(v0 * c) +/- (c * v1) --> (covov) c * (v0 +/- v1)\n"));
 
                     return (synthesis_result) ? result : error_node();
                  }
               }
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
               else if (!expr_gen.valid_operator(o1,f1))
                  return error_node();
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
               else
                  return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vovovov_expression1
         {
            typedef typename vovovov_t::type1 node_type;
            typedef typename vovovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 (v1 o1 (v2 o2 v3))
               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vovov->t0();
               const Type& v2 = vovov->t1();
               const Type& v3 = vovov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovov->f0();
               binary_functor_t f2 = vovov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen,id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 (v1 o1 (v2 o2 v3))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_vovovoc_expression1
         {
            typedef typename vovovoc_t::type1 node_type;
            typedef typename vovovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 (v1 o1 (v2 o2 c))
               typedef typename synthesize_vovoc_expression1::node_type lcl_vovoc_t;
 
               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vovoc->t0();
               const Type& v2 = vovoc->t1();
               const Type   c = vovoc->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovoc->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovoc->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovoc->f0();
               binary_functor_t f2 = vovoc->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 (v1 o1 (v2 o2 c))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_vovocov_expression1
         {
            typedef typename vovocov_t::type1 node_type;
            typedef typename vovocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 (v1 o1 (c o2 v2))
               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vocov->t0();
               const Type   c = vocov->t1();
               const Type& v2 = vocov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vocov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vocov->f0();
               binary_functor_t f2 = vocov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
 
               if (synthesis_result)
                  return result;
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 (v1 o1 (c o2 v2))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_vocovov_expression1
         {
            typedef typename vocovov_t::type1 node_type;
            typedef typename vocovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 (c o1 (v1 o2 v2))
               typedef typename synthesize_covov_expression1::node_type lcl_covov_t;
 
               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type   c = covov->t0();
               const Type& v1 = covov->t1();
               const Type& v2 = covov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(covov->f0());
               const details::operator_type o2 = expr_gen.get_operator(covov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = covov->f0();
               binary_functor_t f2 = covov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 (c o1 (v1 o2 v2))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_covovov_expression1
         {
            typedef typename covovov_t::type1 node_type;
            typedef typename covovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // c o0 (v0 o1 (v1 o2 v2))
               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
               const Type   c = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vovov->t0();
               const Type& v1 = vovov->t1();
               const Type& v2 = vovov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovov->f0();
               binary_functor_t f2 = vovov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("c o0 (v0 o1 (v1 o2 v2))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_covocov_expression1
         {
            typedef typename covocov_t::type1 node_type;
            typedef typename covocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // c0 o0 (v0 o1 (c1 o2 v1))
               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
               const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vocov->t0();
               const Type  c1 = vocov->t1();
               const Type& v1 = vocov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vocov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vocov->f0();
               binary_functor_t f2 = vocov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("c0 o0 (v0 o1 (c1 o2 v1))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_vocovoc_expression1
         {
            typedef typename vocovoc_t::type1 node_type;
            typedef typename vocovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 (c0 o1 (v1 o2 c2))
               typedef typename synthesize_covoc_expression1::node_type lcl_covoc_t;
 
               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type  c0 = covoc->t0();
               const Type& v1 = covoc->t1();
               const Type  c1 = covoc->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(covoc->f0());
               const details::operator_type o2 = expr_gen.get_operator(covoc->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = covoc->f0();
               binary_functor_t f2 = covoc->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 (c0 o1 (v1 o2 c2))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_covovoc_expression1
         {
            typedef typename covovoc_t::type1 node_type;
            typedef typename covovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // c0 o0 (v0 o1 (v1 o2 c1))
               typedef typename synthesize_vovoc_expression1::node_type lcl_vovoc_t;
 
               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
               const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vovoc->t0();
               const Type& v1 = vovoc->t1();
               const Type  c1 = vovoc->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovoc->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovoc->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovoc->f0();
               binary_functor_t f2 = vovoc->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("c0 o0 (v0 o1 (v1 o2 c1))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_vococov_expression1
         {
            typedef typename vococov_t::type1 node_type;
            typedef typename vococov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 (c0 o1 (c1 o2 v1))
               typedef typename synthesize_cocov_expression1::node_type lcl_cocov_t;
 
               const lcl_cocov_t* cocov = static_cast<const lcl_cocov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type  c0 = cocov->t0();
               const Type  c1 = cocov->t1();
               const Type& v1 = cocov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(cocov->f0());
               const details::operator_type o2 = expr_gen.get_operator(cocov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = cocov->f0();
               binary_functor_t f2 = cocov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 (c0 o1 (c1 o2 v1))\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"  << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t))";
            }
         };
 
         struct synthesize_vovovov_expression2
         {
            typedef typename vovovov_t::type2 node_type;
            typedef typename vovovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 ((v1 o1 v2) o2 v3)
               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vovov->t0();
               const Type& v2 = vovov->t1();
               const Type& v3 = vovov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovov->f0();
               binary_functor_t f2 = vovov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 ((v1 o1 v2) o2 v3)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vovovoc_expression2
         {
            typedef typename vovovoc_t::type2 node_type;
            typedef typename vovovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 ((v1 o1 v2) o2 c)
               typedef typename synthesize_vovoc_expression0::node_type lcl_vovoc_t;
 
               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vovoc->t0();
               const Type& v2 = vovoc->t1();
               const Type   c = vovoc->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovoc->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovoc->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovoc->f0();
               binary_functor_t f2 = vovoc->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 ((v1 o1 v2) o2 c)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vovocov_expression2
         {
            typedef typename vovocov_t::type2 node_type;
            typedef typename vovocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 ((v1 o1 c) o2 v2)
               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v1 = vocov->t0();
               const Type   c = vocov->t1();
               const Type& v2 = vocov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vocov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vocov->f0();
               binary_functor_t f2 = vocov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 ((v1 o1 c) o2 v2)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vocovov_expression2
         {
            typedef typename vocovov_t::type2 node_type;
            typedef typename vocovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 ((c o1 v1) o2 v2)
               typedef typename synthesize_covov_expression0::node_type lcl_covov_t;
 
               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type   c = covov->t0();
               const Type& v1 = covov->t1();
               const Type& v2 = covov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(covov->f0());
               const details::operator_type o2 = expr_gen.get_operator(covov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = covov->f0();
               binary_functor_t f2 = covov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 ((c o1 v1) o2 v2)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_covovov_expression2
         {
            typedef typename covovov_t::type2 node_type;
            typedef typename covovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // c o0 ((v1 o1 v2) o2 v3)
               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
               const Type   c = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vovov->t0();
               const Type& v1 = vovov->t1();
               const Type& v2 = vovov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovov->f0();
               binary_functor_t f2 = vovov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("c o0 ((v1 o1 v2) o2 v3)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
        };
 
         struct synthesize_covocov_expression2
         {
            typedef typename covocov_t::type2 node_type;
            typedef typename covocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // c0 o0 ((v0 o1 c1) o2 v1)
               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
               const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vocov->t0();
               const Type  c1 = vocov->t1();
               const Type& v1 = vocov->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o2 = expr_gen.get_operator(vocov->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vocov->f0();
               binary_functor_t f2 = vocov->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("c0 o0 ((v0 o1 c1) o2 v1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vocovoc_expression2
         {
            typedef typename vocovoc_t::type2 node_type;
            typedef typename vocovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // v0 o0 ((c0 o1 v1) o2 c1)
               typedef typename synthesize_covoc_expression0::node_type lcl_covoc_t;
 
               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[1]);
               const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type  c0 = covoc->t0();
               const Type& v1 = covoc->t1();
               const Type  c1 = covoc->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(covoc->f0());
               const details::operator_type o2 = expr_gen.get_operator(covoc->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = covoc->f0();
               binary_functor_t f2 = covoc->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("v0 o0 ((c0 o1 v1) o2 c1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_covovoc_expression2
         {
            typedef typename covovoc_t::type2 node_type;
            typedef typename covovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // c0 o0 ((v0 o1 v1) o2 c1)
               typedef typename synthesize_vovoc_expression0::node_type lcl_vovoc_t;
 
               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
               const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
               const Type& v0 = vovoc->t0();
               const Type& v1 = vovoc->t1();
               const Type  c1 = vovoc->t2();
               const details::operator_type o0 = operation;
               const details::operator_type o1 = expr_gen.get_operator(vovoc->f0());
               const details::operator_type o2 = expr_gen.get_operator(vovoc->f1());
 
               binary_functor_t f0 = reinterpret_cast<binary_functor_t>(0);
               binary_functor_t f1 = vovoc->f0();
               binary_functor_t f2 = vovoc->f1();
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o0,f0))
                  return error_node();
 
               exprtk_debug(("c0 o0 ((v0 o1 v1) o2 c1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "t"   << expr_gen.to_str(o0)
                  << "((t" << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t)";
            }
         };
 
         struct synthesize_vococov_expression2
         {
            typedef typename vococov_t::type2 node_type;
            static inline expression_node_ptr process(expression_generator<Type>&,
                                                      const details::operator_type&,
                                                      expression_node_ptr (&)[2])
            {
               // v0 o0 ((c0 o1 c1) o2 v1) - Not possible
               exprtk_debug(("v0 o0 ((c0 o1 c1) o2 v1) - Not possible\n"));
               return error_node();
            }
 
            static inline std::string id(expression_generator<Type>&,
                                         const details::operator_type,
                                         const details::operator_type,
                                         const details::operator_type)
            {
               return "INVALID";
            }
         };
 
         struct synthesize_vovovov_expression3
         {
            typedef typename vovovov_t::type3 node_type;
            typedef typename vovovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 v1) o1 v2) o2 v3
               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
               const Type& v0 = vovov->t0();
               const Type& v1 = vovov->t1();
               const Type& v2 = vovov->t2();
               const Type& v3 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vovov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vovov->f0();
               binary_functor_t f1 = vovov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 v1) o1 v2) o2 v3\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vovovoc_expression3
         {
            typedef typename vovovoc_t::type3 node_type;
            typedef typename vovovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 v1) o1 v2) o2 c
               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
               const Type& v0 = vovov->t0();
               const Type& v1 = vovov->t1();
               const Type& v2 = vovov->t2();
               const Type   c = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vovov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vovov->f0();
               binary_functor_t f1 = vovov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 v1) o1 v2) o2 c\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vovocov_expression3
         {
            typedef typename vovocov_t::type3 node_type;
            typedef typename vovocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 v1) o1 c) o2 v2
               typedef typename synthesize_vovoc_expression0::node_type lcl_vovoc_t;
 
               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[0]);
               const Type& v0 = vovoc->t0();
               const Type& v1 = vovoc->t1();
               const Type   c = vovoc->t2();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vovoc->f0());
               const details::operator_type o1 = expr_gen.get_operator(vovoc->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vovoc->f0();
               binary_functor_t f1 = vovoc->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 v1) o1 c) o2 v2\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vocovov_expression3
         {
            typedef typename vocovov_t::type3 node_type;
            typedef typename vocovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 c) o1 v1) o2 v2
               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
               const Type& v0 = vocov->t0();
               const Type   c = vocov->t1();
               const Type& v1 = vocov->t2();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vocov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vocov->f0();
               binary_functor_t f1 = vocov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 c) o1 v1) o2 v2\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_covovov_expression3
         {
            typedef typename covovov_t::type3 node_type;
            typedef typename covovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((c o0 v0) o1 v1) o2 v2
               typedef typename synthesize_covov_expression0::node_type lcl_covov_t;
 
               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
               const Type   c = covov->t0();
               const Type& v0 = covov->t1();
               const Type& v1 = covov->t2();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(covov->f0());
               const details::operator_type o1 = expr_gen.get_operator(covov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = covov->f0();
               binary_functor_t f1 = covov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((c o0 v0) o1 v1) o2 v2\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_covocov_expression3
         {
            typedef typename covocov_t::type3 node_type;
            typedef typename covocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((c0 o0 v0) o1 c1) o2 v1
               typedef typename synthesize_covoc_expression0::node_type lcl_covoc_t;
 
               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[0]);
               const Type  c0 = covoc->t0();
               const Type& v0 = covoc->t1();
               const Type  c1 = covoc->t2();
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(covoc->f0());
               const details::operator_type o1 = expr_gen.get_operator(covoc->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = covoc->f0();
               binary_functor_t f1 = covoc->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((c0 o0 v0) o1 c1) o2 v1\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vocovoc_expression3
         {
            typedef typename vocovoc_t::type3 node_type;
            typedef typename vocovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 c0) o1 v1) o2 c1
               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
               const Type& v0 = vocov->t0();
               const Type  c0 = vocov->t1();
               const Type& v1 = vocov->t2();
               const Type  c1 = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vocov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vocov->f0();
               binary_functor_t f1 = vocov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 c0) o1 v1) o2 c1\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_covovoc_expression3
         {
            typedef typename covovoc_t::type3 node_type;
            typedef typename covovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((c0 o0 v0) o1 v1) o2 c1
               typedef typename synthesize_covov_expression0::node_type lcl_covov_t;
 
               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
               const Type  c0 = covov->t0();
               const Type& v0 = covov->t1();
               const Type& v1 = covov->t2();
               const Type  c1 = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = expr_gen.get_operator(covov->f0());
               const details::operator_type o1 = expr_gen.get_operator(covov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = covov->f0();
               binary_functor_t f1 = covov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((c0 o0 v0) o1 v1) o2 c1\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vococov_expression3
         {
            typedef typename vococov_t::type3 node_type;
            typedef typename vococov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 c0) o1 c1) o2 v1
               typedef typename synthesize_vococ_expression0::node_type lcl_vococ_t;
 
               const lcl_vococ_t* vococ = static_cast<const lcl_vococ_t*>(branch[0]);
               const Type& v0 = vococ->t0();
               const Type  c0 = vococ->t1();
               const Type  c1 = vococ->t2();
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vococ->f0());
               const details::operator_type o1 = expr_gen.get_operator(vococ->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vococ->f0();
               binary_functor_t f1 = vococ->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 c0) o1 c1) o2 v1\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "((t" << expr_gen.to_str(o0)
                  << "t)"  << expr_gen.to_str(o1)
                  << "t)"  << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vovovov_expression4
         {
            typedef typename vovovov_t::type4 node_type;
            typedef typename vovovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // (v0 o0 (v1 o1 v2)) o2 v3
               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
               const Type& v0 = vovov->t0();
               const Type& v1 = vovov->t1();
               const Type& v2 = vovov->t2();
               const Type& v3 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vovov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vovov->f0();
               binary_functor_t f1 = vovov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("(v0 o0 (v1 o1 v2)) o2 v3\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, v3, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vovovoc_expression4
         {
            typedef typename vovovoc_t::type4 node_type;
            typedef typename vovovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 (v1 o1 v2)) o2 c)
               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
               const Type& v0 = vovov->t0();
               const Type& v1 = vovov->t1();
               const Type& v2 = vovov->t2();
               const Type   c = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = expr_gen.get_operator(vovov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vovov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vovov->f0();
               binary_functor_t f1 = vovov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, c, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 (v1 o1 v2)) o2 c)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, v2, c, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vovocov_expression4
         {
            typedef typename vovocov_t::type4 node_type;
            typedef typename vovocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 (v1 o1 c)) o2 v1)
               typedef typename synthesize_vovoc_expression1::node_type lcl_vovoc_t;
 
               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[0]);
               const Type& v0 = vovoc->t0();
               const Type& v1 = vovoc->t1();
               const Type   c = vovoc->t2();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vovoc->f0());
               const details::operator_type o1 = expr_gen.get_operator(vovoc->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vovoc->f0();
               binary_functor_t f1 = vovoc->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, c, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 (v1 o1 c)) o2 v1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, v1, c, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vocovov_expression4
         {
            typedef typename vocovov_t::type4 node_type;
            typedef typename vocovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 (c o1 v1)) o2 v2)
               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
               const Type& v0 = vocov->t0();
               const Type   c = vocov->t1();
               const Type& v1 = vocov->t2();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vocov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vocov->f0();
               binary_functor_t f1 = vocov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 (c o1 v1)) o2 v2)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_covovov_expression4
         {
            typedef typename covovov_t::type4 node_type;
            typedef typename covovov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((c o0 (v0 o1 v1)) o2 v2)
               typedef typename synthesize_covov_expression1::node_type lcl_covov_t;
 
               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
               const Type   c = covov->t0();
               const Type& v0 = covov->t1();
               const Type& v1 = covov->t2();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(covov->f0());
               const details::operator_type o1 = expr_gen.get_operator(covov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = covov->f0();
               binary_functor_t f1 = covov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c, v0, v1, v2, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((c o0 (v0 o1 v1)) o2 v2)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c, v0, v1, v2, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_covocov_expression4
         {
            typedef typename covocov_t::type4 node_type;
            typedef typename covocov_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((c0 o0 (v0 o1 c1)) o2 v1)
               typedef typename synthesize_covoc_expression1::node_type lcl_covoc_t;
 
               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[0]);
               const Type  c0 = covoc->t0();
               const Type& v0 = covoc->t1();
               const Type  c1 = covoc->t2();
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[1])->ref();
               const details::operator_type o0 = expr_gen.get_operator(covoc->f0());
               const details::operator_type o1 = expr_gen.get_operator(covoc->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = covoc->f0();
               binary_functor_t f1 = covoc->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, c1, v1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((c0 o0 (v0 o1 c1)) o2 v1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, c1, v1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vocovoc_expression4
         {
            typedef typename vocovoc_t::type4 node_type;
            typedef typename vocovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((v0 o0 (c0 o1 v1)) o2 c1)
               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
               const Type& v0 = vocov->t0();
               const Type  c0 = vocov->t1();
               const Type& v1 = vocov->t2();
               const Type  c1 = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = expr_gen.get_operator(vocov->f0());
               const details::operator_type o1 = expr_gen.get_operator(vocov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = vocov->f0();
               binary_functor_t f1 = vocov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), v0, c0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((v0 o0 (c0 o1 v1)) o2 c1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), v0, c0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_covovoc_expression4
         {
            typedef typename covovoc_t::type4 node_type;
            typedef typename covovoc_t::sf4_type sf4_type;
            typedef typename node_type::T0 T0;
            typedef typename node_type::T1 T1;
            typedef typename node_type::T2 T2;
            typedef typename node_type::T3 T3;
 
            static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               // ((c0 o0 (v0 o1 v1)) o2 c1)
               typedef typename synthesize_covov_expression1::node_type lcl_covov_t;
 
               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
               const Type  c0 = covov->t0();
               const Type& v0 = covov->t1();
               const Type& v1 = covov->t2();
               const Type  c1 = static_cast<details::literal_node<Type>*>(branch[1])->value();
               const details::operator_type o0 = expr_gen.get_operator(covov->f0());
               const details::operator_type o1 = expr_gen.get_operator(covov->f1());
               const details::operator_type o2 = operation;
 
               binary_functor_t f0 = covov->f0();
               binary_functor_t f1 = covov->f1();
               binary_functor_t f2 = reinterpret_cast<binary_functor_t>(0);
 
               details::free_node(*(expr_gen.node_allocator_),branch[0]);
               details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
               expression_node_ptr result = error_node();
 
               const bool synthesis_result =
                  synthesize_sf4ext_expression::template compile<T0, T1, T2, T3>
                     (expr_gen, id(expr_gen, o0, o1, o2), c0, v0, v1, c1, result);
 
               if (synthesis_result)
                  return result;
               else if (!expr_gen.valid_operator(o2,f2))
                  return error_node();
 
               exprtk_debug(("((c0 o0 (v0 o1 v1)) o2 c1)\n"));
 
               return node_type::allocate(*(expr_gen.node_allocator_), c0, v0, v1, c1, f0, f1, f2);
            }
 
            static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "(t" << expr_gen.to_str(o1)
                  << "t)" << expr_gen.to_str(o2)
                  << "t";
            }
         };
 
         struct synthesize_vococov_expression4
         {
            typedef typename vococov_t::type4 node_type;
            static inline expression_node_ptr process(expression_generator<Type>&,
                                                      const details::operator_type&,
                                                      expression_node_ptr (&)[2])
            {
               // ((v0 o0 (c0 o1 c1)) o2 v1) - Not possible
               exprtk_debug(("((v0 o0 (c0 o1 c1)) o2 v1) - Not possible\n"));
               return error_node();
            }
 
            static inline std::string id(expression_generator<Type>&,
                                         const details::operator_type,
                                         const details::operator_type,
                                         const details::operator_type)
            {
               return "INVALID";
            }
         };
         #endif
 
         inline expression_node_ptr synthesize_uvouv_expression(const details::operator_type& operation, expression_node_ptr (&branch)[2])
         {
            // Definition: uv o uv
            details::operator_type o0 = static_cast<details::uv_base_node<Type>*>(branch[0])->operation();
            details::operator_type o1 = static_cast<details::uv_base_node<Type>*>(branch[1])->operation();
            const Type& v0 = static_cast<details::uv_base_node<Type>*>(branch[0])->v();
            const Type& v1 = static_cast<details::uv_base_node<Type>*>(branch[1])->v();
            unary_functor_t u0 = reinterpret_cast<unary_functor_t> (0);
            unary_functor_t u1 = reinterpret_cast<unary_functor_t> (0);
            binary_functor_t f = reinterpret_cast<binary_functor_t>(0);
 
            if (!valid_operator(o0,u0))
               return error_node();
            else if (!valid_operator(o1,u1))
               return error_node();
            else if (!valid_operator(operation,f))
               return error_node();
 
            expression_node_ptr result = error_node();
 
            if (
                 (details::e_neg == o0) &&
                 (details::e_neg == o1)
               )
            {
               switch (operation)
               {
                  // (-v0 + -v1) --> -(v0 + v1)
                  case details::e_add : result = (*this)(details::e_neg,
                                                    node_allocator_->
                                                       allocate_rr<typename details::
                                                          vov_node<Type,details::add_op<Type> > >(v0, v1));
                                        exprtk_debug(("(-v0 + -v1) --> -(v0 + v1)\n"));
                                        break;
 
                  // (-v0 - -v1) --> (v1 - v0)
                  case details::e_sub : result = node_allocator_->
                                                    allocate_rr<typename details::
                                                       vov_node<Type,details::sub_op<Type> > >(v1, v0);
                                        exprtk_debug(("(-v0 - -v1) --> (v1 - v0)\n"));
                                        break;
 
                  // (-v0 * -v1) --> (v0 * v1)
                  case details::e_mul : result = node_allocator_->
                                                    allocate_rr<typename details::
                                                       vov_node<Type,details::mul_op<Type> > >(v0, v1);
                                        exprtk_debug(("(-v0 * -v1) --> (v0 * v1)\n"));
                                        break;
 
                  // (-v0 / -v1) --> (v0 / v1)
                  case details::e_div : result = node_allocator_->
                                                    allocate_rr<typename details::
                                                       vov_node<Type,details::div_op<Type> > >(v0, v1);
                                        exprtk_debug(("(-v0 / -v1) --> (v0 / v1)\n"));
                                        break;
 
                  default             : break;
               }
            }
 
            if (0 == result)
            {
               result = node_allocator_->
                            allocate_rrrrr<typename details::uvouv_node<Type> >(v0, v1, u0, u1, f);
            }
 
            details::free_all_nodes(*node_allocator_,branch);
            return result;
         }
 
         #undef basic_opr_switch_statements
         #undef extended_opr_switch_statements
         #undef unary_opr_switch_statements
 
         #ifndef exprtk_disable_string_capabilities
 
         #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) \
 
         template <typename T0, typename T1>
         inline expression_node_ptr synthesize_str_xrox_expression_impl(const details::operator_type& opr,
                                                                        T0 s0, T1 s1,
                                                                        range_t rp0)
         {
            switch (opr)
            {
               #define case_stmt(op0, op1)                                                                      \
               case op0 : return node_allocator_->                                                              \
                             allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp0);                                                                  \
 
               string_opr_switch_statements
               #undef case_stmt
               default : return error_node();
            }
         }
 
         template <typename T0, typename T1>
         inline expression_node_ptr synthesize_str_xoxr_expression_impl(const details::operator_type& opr,
                                                                        T0 s0, T1 s1,
                                                                        range_t rp1)
         {
            switch (opr)
            {
               #define case_stmt(op0, op1)                                                                      \
               case op0 : return node_allocator_->                                                              \
                             allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp1);                                                                  \
 
               string_opr_switch_statements
               #undef case_stmt
               default : return error_node();
            }
         }
 
         template <typename T0, typename T1>
         inline expression_node_ptr synthesize_str_xroxr_expression_impl(const details::operator_type& opr,
                                                                         T0 s0, T1 s1,
                                                                         range_t rp0, range_t rp1)
         {
            switch (opr)
            {
               #define case_stmt(op0, op1)                                                                        \
               case op0 : return node_allocator_->                                                                \
                             allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp0, rp1);                                                               \
 
               string_opr_switch_statements
               #undef case_stmt
               default : return error_node();
            }
         }
 
         template <typename T0, typename T1>
         inline expression_node_ptr synthesize_sos_expression_impl(const details::operator_type& opr, T0 s0, T1 s1)
         {
            switch (opr)
            {
               #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); \
 
               string_opr_switch_statements
               #undef case_stmt
               default : return error_node();
            }
         }
 
         inline expression_node_ptr synthesize_sos_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string& s0 = static_cast<details::stringvar_node<Type>*>(branch[0])->ref();
            std::string& s1 = static_cast<details::stringvar_node<Type>*>(branch[1])->ref();
 
            return synthesize_sos_expression_impl<std::string&,std::string&>(opr, s0, s1);
         }
 
         inline expression_node_ptr synthesize_sros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*>   (branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();
 
            static_cast<details::string_range_node<Type>*>(branch[0])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
 
            return synthesize_str_xrox_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0);
         }
 
         inline expression_node_ptr synthesize_sosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::stringvar_node<Type>*>   (branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();
 
            static_cast<details::string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xoxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp1);
         }
 
         inline expression_node_ptr synthesize_socsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::stringvar_node<Type>*>         (branch[0])->ref  ();
            std::string   s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            range_t      rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();
 
            static_cast<details::const_string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xoxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp1);
         }
 
         inline expression_node_ptr synthesize_srosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();
 
            static_cast<details::string_range_node<Type>*>(branch[0])->range_ref().clear();
            static_cast<details::string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xroxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0, rp1);
         }
 
         inline expression_node_ptr synthesize_socs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string& s0 = static_cast<     details::stringvar_node<Type>*>(branch[0])->ref();
            std::string  s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str();
 
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_sos_expression_impl<std::string&, const std::string>(opr, s0, s1);
         }
 
         inline expression_node_ptr synthesize_csos_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string  s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
            std::string& s1 = static_cast<details::stringvar_node<Type>*     >(branch[1])->ref();
 
            details::free_node(*node_allocator_,branch[0]);
 
            return synthesize_sos_expression_impl<const std::string,std::string&>(opr, s0, s1);
         }
 
         inline expression_node_ptr synthesize_csosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string  s0  = static_cast<details::string_literal_node<Type>*>(branch[0])->str  ();
            std::string& s1  = static_cast<details::string_range_node<Type>*  >(branch[1])->ref  ();
            range_t      rp1 = static_cast<details::string_range_node<Type>*  >(branch[1])->range();
 
            static_cast<details::string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xoxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp1);
         }
 
         inline expression_node_ptr synthesize_srocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*  >(branch[0])->ref  ();
            std::string   s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*  >(branch[0])->range();
 
            static_cast<details::string_range_node<Type>*>(branch[0])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xrox_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0);
         }
 
         inline expression_node_ptr synthesize_srocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*      >(branch[0])->ref  ();
            std::string   s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*      >(branch[0])->range();
            range_t      rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();
 
            static_cast<details::string_range_node<Type>*>      (branch[0])->range_ref().clear();
            static_cast<details::const_string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xroxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0, rp1);
         }
 
         inline expression_node_ptr synthesize_csocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
            const std::string s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str();
 
            expression_node_ptr result = error_node();
 
            if (details::e_add == opr)
               result = node_allocator_->allocate_c<details::string_literal_node<Type> >(s0 + s1);
            else if (details::e_in == opr)
               result = node_allocator_->allocate_c<details::literal_node<Type> >(details::in_op   <Type>::process(s0,s1));
            else if (details::e_like == opr)
               result = node_allocator_->allocate_c<details::literal_node<Type> >(details::like_op <Type>::process(s0,s1));
            else if (details::e_ilike == opr)
               result = node_allocator_->allocate_c<details::literal_node<Type> >(details::ilike_op<Type>::process(s0,s1));
            else
            {
               expression_node_ptr temp = synthesize_sos_expression_impl<const std::string, const std::string>(opr, s0, s1);
 
               const Type v = temp->value();
 
               details::free_node(*node_allocator_,temp);
 
               result = node_allocator_->allocate<literal_node_t>(v);
            }
 
            details::free_all_nodes(*node_allocator_,branch);
 
            return result;
         }
 
         inline expression_node_ptr synthesize_csocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::string_literal_node<Type>*    >(branch[0])->str  ();
                  std::string s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            range_t          rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();
 
            static_cast<details::const_string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xoxr_expression_impl<const std::string, const std::string>(opr, s0, s1, rp1);
         }
 
         inline expression_node_ptr synthesize_csros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string   s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*         >(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();
 
            static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
 
            return synthesize_str_xrox_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0);
         }
 
         inline expression_node_ptr synthesize_csrosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string  s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
                  std::string& s1 = static_cast<details::string_range_node<Type>*      >(branch[1])->ref  ();
            const range_t     rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();
            const range_t     rp1 = static_cast<details::string_range_node<Type>*      >(branch[1])->range();
 
            static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear();
            static_cast<details::string_range_node<Type>*>      (branch[1])->range_ref().clear();
 
            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);
 
            return synthesize_str_xroxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0, rp1);
         }
 
         inline expression_node_ptr synthesize_csrocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            const std::string s1 = static_cast<details::string_literal_node<Type>*    >(branch[1])->str  ();
            const range_t    rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();
 
            static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear();
 
            details::free_all_nodes(*node_allocator_,branch);
 
            return synthesize_str_xrox_expression_impl<const std::string,std::string>(opr, s0, s1, rp0);
         }
 
         inline expression_node_ptr synthesize_csrocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            const std::string s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            const range_t    rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();
            const range_t    rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();
 
            static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear();
            static_cast<details::const_string_range_node<Type>*>(branch[1])->range_ref().clear();
 
            details::free_all_nodes(*node_allocator_,branch);
 
            return synthesize_str_xroxr_expression_impl<const std::string, const std::string>(opr, s0, s1, rp0, rp1);
         }
 
         inline expression_node_ptr synthesize_strogen_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            switch (opr)
            {
               #define case_stmt(op0, op1)                                                      \
               case op0 : return node_allocator_->                                              \
                             allocate_ttt<typename details::str_sogens_node<Type,op1<Type> > >  \
                                (opr, branch[0], branch[1]);                                    \
 
               string_opr_switch_statements
               #undef case_stmt
               default : return error_node();
            }
         }
         #endif
 
         #ifndef exprtk_disable_string_capabilities
         inline expression_node_ptr synthesize_string_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            if ((0 == branch[0]) || (0 == branch[1]))
            {
               details::free_all_nodes(*node_allocator_,branch);
 
               return error_node();
            }
 
            const bool b0_is_s   = details::is_string_node            (branch[0]);
            const bool b0_is_cs  = details::is_const_string_node      (branch[0]);
            const bool b0_is_sr  = details::is_string_range_node      (branch[0]);
            const bool b0_is_csr = details::is_const_string_range_node(branch[0]);
 
            const bool b1_is_s   = details::is_string_node            (branch[1]);
            const bool b1_is_cs  = details::is_const_string_node      (branch[1]);
            const bool b1_is_sr  = details::is_string_range_node      (branch[1]);
            const bool b1_is_csr = details::is_const_string_range_node(branch[1]);
 
            const bool b0_is_gen = details::is_string_assignment_node (branch[0]) ||
                                   details::is_genricstring_range_node(branch[0]) ||
                                   details::is_string_concat_node     (branch[0]) ||
                                   details::is_string_function_node   (branch[0]) ||
                                   details::is_string_condition_node  (branch[0]) ||
                                   details::is_string_ccondition_node (branch[0]) ||
                                   details::is_string_vararg_node     (branch[0]) ;
 
            const bool b1_is_gen = details::is_string_assignment_node (branch[1]) ||
                                   details::is_genricstring_range_node(branch[1]) ||
                                   details::is_string_concat_node     (branch[1]) ||
                                   details::is_string_function_node   (branch[1]) ||
                                   details::is_string_condition_node  (branch[1]) ||
                                   details::is_string_ccondition_node (branch[1]) ||
                                   details::is_string_vararg_node     (branch[1]) ;
 
            if (details::e_add == opr)
            {
               if (!b0_is_cs || !b1_is_cs)
               {
                  return synthesize_expression<string_concat_node_t,2>(opr,branch);
               }
            }
 
            if (b0_is_gen || b1_is_gen)
            {
               return synthesize_strogen_expression(opr,branch);
            }
            else if (b0_is_s)
            {
               if      (b1_is_s  ) return synthesize_sos_expression   (opr,branch);
               else if (b1_is_cs ) return synthesize_socs_expression  (opr,branch);
               else if (b1_is_sr ) return synthesize_sosr_expression  (opr,branch);
               else if (b1_is_csr) return synthesize_socsr_expression (opr,branch);
            }
            else if (b0_is_cs)
            {
               if      (b1_is_s  ) return synthesize_csos_expression  (opr,branch);
               else if (b1_is_cs ) return synthesize_csocs_expression (opr,branch);
               else if (b1_is_sr ) return synthesize_csosr_expression (opr,branch);
               else if (b1_is_csr) return synthesize_csocsr_expression(opr,branch);
            }
            else if (b0_is_sr)
            {
               if      (b1_is_s  ) return synthesize_sros_expression  (opr,branch);
               else if (b1_is_sr ) return synthesize_srosr_expression (opr,branch);
               else if (b1_is_cs ) return synthesize_srocs_expression (opr,branch);
               else if (b1_is_csr) return synthesize_srocsr_expression(opr,branch);
            }
            else if (b0_is_csr)
            {
               if      (b1_is_s  ) return synthesize_csros_expression  (opr,branch);
               else if (b1_is_sr ) return synthesize_csrosr_expression (opr,branch);
               else if (b1_is_cs ) return synthesize_csrocs_expression (opr,branch);
               else if (b1_is_csr) return synthesize_csrocsr_expression(opr,branch);
            }
 
            return error_node();
         }
         #else
         inline expression_node_ptr synthesize_string_expression(const details::operator_type&, expression_node_ptr (&branch)[2])
         {
            details::free_all_nodes(*node_allocator_,branch);
            return error_node();
         }
         #endif
 
         #ifndef exprtk_disable_string_capabilities
         inline expression_node_ptr synthesize_string_expression(const details::operator_type& opr, expression_node_ptr (&branch)[3])
         {
            if (details::e_inrange != opr)
               return error_node();
            else if ((0 == branch[0]) || (0 == branch[1]) || (0 == branch[2]))
            {
               details::free_all_nodes(*node_allocator_,branch);
 
               return error_node();
            }
            else if (
                      details::is_const_string_node(branch[0]) &&
                      details::is_const_string_node(branch[1]) &&
                      details::is_const_string_node(branch[2])
                    )
            {
               const std::string s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
               const std::string s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str();
               const std::string s2 = static_cast<details::string_literal_node<Type>*>(branch[2])->str();
 
               const Type v = (((s0 <= s1) && (s1 <= s2)) ? Type(1) : Type(0));
 
               details::free_all_nodes(*node_allocator_,branch);
 
               return node_allocator_->allocate_c<details::literal_node<Type> >(v);
            }
            else if (
                      details::is_string_node(branch[0]) &&
                      details::is_string_node(branch[1]) &&
                      details::is_string_node(branch[2])
                    )
            {
               std::string& s0 = static_cast<details::stringvar_node<Type>*>(branch[0])->ref();
               std::string& s1 = static_cast<details::stringvar_node<Type>*>(branch[1])->ref();
               std::string& s2 = static_cast<details::stringvar_node<Type>*>(branch[2])->ref();
 
               typedef typename details::sosos_node<Type, std::string&, std::string&, std::string&, details::inrange_op<Type> > inrange_t;
 
               return node_allocator_->allocate_type<inrange_t, std::string&, std::string&, std::string&>(s0, s1, s2);
            }
            else if (
                      details::is_const_string_node(branch[0]) &&
                            details::is_string_node(branch[1]) &&
                      details::is_const_string_node(branch[2])
                    )
            {
               std::string  s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
               std::string& s1 = static_cast<details::stringvar_node<Type>*     >(branch[1])->ref();
               std::string  s2 = static_cast<details::string_literal_node<Type>*>(branch[2])->str();
 
               typedef typename details::sosos_node<Type, std::string, std::string&, std::string, details::inrange_op<Type> > inrange_t;
 
               details::free_node(*node_allocator_,branch[0]);
               details::free_node(*node_allocator_,branch[2]);
 
               return node_allocator_->allocate_type<inrange_t, std::string, std::string&, std::string>(s0, s1, s2);
            }
            else if (
                            details::is_string_node(branch[0]) &&
                      details::is_const_string_node(branch[1]) &&
                            details::is_string_node(branch[2])
                    )
            {
               std::string&  s0 = static_cast<details::stringvar_node<Type>*     >(branch[0])->ref();
               std::string   s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str();
               std::string&  s2 = static_cast<details::stringvar_node<Type>*     >(branch[2])->ref();
 
               typedef typename details::sosos_node<Type, std::string&, std::string, std::string&, details::inrange_op<Type> > inrange_t;
 
               details::free_node(*node_allocator_,branch[1]);
 
               return node_allocator_->allocate_type<inrange_t, std::string&, std::string, std::string&>(s0, s1, s2);
            }
            else if (
                      details::is_string_node(branch[0]) &&
                      details::is_string_node(branch[1]) &&
                      details::is_const_string_node(branch[2])
                    )
            {
               std::string& s0 = static_cast<details::stringvar_node<Type>*     >(branch[0])->ref();
               std::string& s1 = static_cast<details::stringvar_node<Type>*     >(branch[1])->ref();
               std::string  s2 = static_cast<details::string_literal_node<Type>*>(branch[2])->str();
 
               typedef typename details::sosos_node<Type, std::string&, std::string&, std::string, details::inrange_op<Type> > inrange_t;
 
               details::free_node(*node_allocator_,branch[2]);
 
               return node_allocator_->allocate_type<inrange_t, std::string&, std::string&, std::string>(s0, s1, s2);
            }
            else if (
                      details::is_const_string_node(branch[0]) &&
                      details::      is_string_node(branch[1]) &&
                      details::      is_string_node(branch[2])
                    )
            {
               std::string  s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
               std::string& s1 = static_cast<details::stringvar_node<Type>*     >(branch[1])->ref();
               std::string& s2 = static_cast<details::stringvar_node<Type>*     >(branch[2])->ref();
 
               typedef typename details::sosos_node<Type, std::string, std::string&, std::string&, details::inrange_op<Type> > inrange_t;
 
               details::free_node(*node_allocator_,branch[0]);
 
               return node_allocator_->allocate_type<inrange_t, std::string, std::string&, std::string&>(s0, s1, s2);
            }
            else
               return error_node();
         }
         #else
         inline expression_node_ptr synthesize_string_expression(const details::operator_type&, expression_node_ptr (&branch)[3])
         {
            details::free_all_nodes(*node_allocator_,branch);
            return error_node();
         }
         #endif
 
         inline expression_node_ptr synthesize_null_expression(const details::operator_type& operation, expression_node_ptr (&branch)[2])
         {
            /*
             Note: The following are the type promotion rules
             that relate to operations that include 'null':
             0. null ==/!=     null --> true false
             1. null operation null --> null
             2. x    ==/!=     null --> true/false
             3. null ==/!=     x    --> true/false
             4. x   operation  null --> x
             5. null operation x    --> x
            */
 
            typedef typename details::null_eq_node<T> nulleq_node_t;
 
            const bool b0_null = details::is_null_node(branch[0]);
            const bool b1_null = details::is_null_node(branch[1]);
 
            if (b0_null && b1_null)
            {
               expression_node_ptr result = error_node();
 
               if (details::e_eq == operation)
                  result = node_allocator_->allocate_c<literal_node_t>(T(1));
               else if (details::e_ne == operation)
                  result = node_allocator_->allocate_c<literal_node_t>(T(0));
 
               if (result)
               {
                  details::free_node(*node_allocator_,branch[0]);
                  details::free_node(*node_allocator_,branch[1]);
 
                  return result;
               }
 
               details::free_node(*node_allocator_,branch[1]);
 
               return branch[0];
            }
            else if (details::e_eq == operation)
            {
               expression_node_ptr result = node_allocator_->
                                                allocate_rc<nulleq_node_t>(branch[b0_null ? 0 : 1],true);
 
               details::free_node(*node_allocator_,branch[b0_null ? 1 : 0]);
 
               return result;
            }
            else if (details::e_ne == operation)
            {
               expression_node_ptr result = node_allocator_->
                                                allocate_rc<nulleq_node_t>(branch[b0_null ? 0 : 1],false);
 
               details::free_node(*node_allocator_,branch[b0_null ? 1 : 0]);
 
               return result;
            }
            else if (b0_null)
            {
               details::free_node(*node_allocator_,branch[0]);
               branch[0] = branch[1];
               branch[1] = error_node();
            }
            else if (b1_null)
            {
               details::free_node(*node_allocator_,branch[1]);
               branch[1] = error_node();
            }
 
            if (
                 (details::e_add == operation) || (details::e_sub == operation) ||
                 (details::e_mul == operation) || (details::e_div == operation) ||
                 (details::e_mod == operation) || (details::e_pow == operation)
               )
            {
               return branch[0];
            }
 
            details::free_node(*node_allocator_, branch[0]);
 
            if (
                 (details::e_lt    == operation) || (details::e_lte  == operation) ||
                 (details::e_gt    == operation) || (details::e_gte  == operation) ||
                 (details::e_and   == operation) || (details::e_nand == operation) ||
                 (details::e_or    == operation) || (details::e_nor  == operation) ||
                 (details::e_xor   == operation) || (details::e_xnor == operation) ||
                 (details::e_in    == operation) || (details::e_like == operation) ||
                 (details::e_ilike == operation)
               )
            {
               return node_allocator_->allocate_c<literal_node_t>(T(0));
            }
 
            return node_allocator_->allocate<details::null_node<Type> >();
         }
 
         template <typename NodeType, std::size_t N>
         inline expression_node_ptr synthesize_expression(const details::operator_type& operation, expression_node_ptr (&branch)[N])
         {
            if (
                 (details::e_in    == operation) ||
                 (details::e_like  == operation) ||
                 (details::e_ilike == operation)
               )
            {
               free_all_nodes(*node_allocator_,branch);
 
               return error_node();
            }
            else if (!details::all_nodes_valid<N>(branch))
            {
               free_all_nodes(*node_allocator_,branch);
 
               return error_node();
            }
            else if ((details::e_default != operation))
            {
               // Attempt simple constant folding optimisation.
               expression_node_ptr expression_point = node_allocator_->allocate<NodeType>(operation,branch);
 
               if (is_constant_foldable<N>(branch))
               {
                  const Type v = expression_point->value();
                  details::free_node(*node_allocator_,expression_point);
 
                  return node_allocator_->allocate<literal_node_t>(v);
               }
 
               if (expression_point && expression_point->valid())
               {
                  return expression_point;
               }
 
               parser_->set_error(parser_error::make_error(
                  parser_error::e_parser,
                  token_t(),
                  "ERR246 - Failed to synthesize node: NodeType",
                  exprtk_error_location));
 
               details::free_node(*node_allocator_, expression_point);
            }
 
            return error_node();
         }
 
         template <typename NodeType, std::size_t N>
         inline expression_node_ptr synthesize_expression(F* f, expression_node_ptr (&branch)[N])
         {
            if (!details::all_nodes_valid<N>(branch))
            {
               free_all_nodes(*node_allocator_,branch);
 
               return error_node();
            }
 
            typedef typename details::function_N_node<T,ifunction_t,N> function_N_node_t;
 
            // Attempt simple constant folding optimisation.
 
            expression_node_ptr expression_point = node_allocator_->allocate<NodeType>(f);
            function_N_node_t* func_node_ptr = dynamic_cast<function_N_node_t*>(expression_point);
 
            if (0 == func_node_ptr)
            {
               free_all_nodes(*node_allocator_,branch);
 
               return error_node();
            }
            else
               func_node_ptr->init_branches(branch);
 
            if (is_constant_foldable<N>(branch) && !f->has_side_effects())
            {
               Type v = expression_point->value();
               details::free_node(*node_allocator_,expression_point);
 
               return node_allocator_->allocate<literal_node_t>(v);
            }
 
            parser_->state_.activate_side_effect("synthesize_expression(function<NT,N>)");
 
            return expression_point;
         }
 
         bool                     strength_reduction_enabled_;
         details::node_allocator* node_allocator_;
         synthesize_map_t         synthesize_map_;
         unary_op_map_t*          unary_op_map_;
         binary_op_map_t*         binary_op_map_;
         inv_binary_op_map_t*     inv_binary_op_map_;
         sf3_map_t*               sf3_map_;
         sf4_map_t*               sf4_map_;
         parser_t*                parser_;
      }; // class expression_generator
 
      inline void set_error(const parser_error::type& error_type)
      {
         error_list_.push_back(error_type);
      }
 
      inline void remove_last_error()
      {
         if (!error_list_.empty())
         {
            error_list_.pop_back();
         }
      }
 
      inline void set_synthesis_error(const std::string& synthesis_error_message)
      {
         if (synthesis_error_.empty())
         {
            synthesis_error_ = synthesis_error_message;
         }
      }
 
      inline void register_local_vars(expression<T>& e)
      {
         for (std::size_t i = 0; i < sem_.size(); ++i)
         {
            scope_element& se = sem_.get_element(i);
 
            if (
                 (scope_element::e_variable == se.type) ||
                 (scope_element::e_vecelem  == se.type)
               )
            {
               if (se.var_node)
               {
                  e.register_local_var(se.var_node);
               }
 
               if (se.data)
               {
                  e.register_local_data(se.data, 1, 0);
               }
            }
            else if (scope_element::e_vector == se.type)
            {
               if (se.vec_node)
               {
                  e.register_local_var(se.vec_node);
               }
 
               if (se.data)
               {
                  e.register_local_data(se.data, se.size, 1);
               }
            }
            #ifndef exprtk_disable_string_capabilities
            else if (scope_element::e_string == se.type)
            {
               if (se.str_node)
               {
                  e.register_local_var(se.str_node);
               }
 
               if (se.data)
               {
                  e.register_local_data(se.data, se.size, 2);
               }
            }
            #endif
 
            se.var_node  = 0;
            se.vec_node  = 0;
            #ifndef exprtk_disable_string_capabilities
            se.str_node  = 0;
            #endif
            se.data      = 0;
            se.ref_count = 0;
            se.active    = false;
         }
      }
 
      inline void register_return_results(expression<T>& e)
      {
         e.register_return_results(results_context_);
         results_context_ = 0;
      }
 
      inline void load_unary_operations_map(unary_op_map_t& m)
      {
         #define register_unary_op(Op, UnaryFunctor)            \
         m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \
 
         register_unary_op(details::e_abs   , details::abs_op  )
         register_unary_op(details::e_acos  , details::acos_op )
         register_unary_op(details::e_acosh , details::acosh_op)
         register_unary_op(details::e_asin  , details::asin_op )
         register_unary_op(details::e_asinh , details::asinh_op)
         register_unary_op(details::e_atanh , details::atanh_op)
         register_unary_op(details::e_ceil  , details::ceil_op )
         register_unary_op(details::e_cos   , details::cos_op  )
         register_unary_op(details::e_cosh  , details::cosh_op )
         register_unary_op(details::e_exp   , details::exp_op  )
         register_unary_op(details::e_expm1 , details::expm1_op)
         register_unary_op(details::e_floor , details::floor_op)
         register_unary_op(details::e_log   , details::log_op  )
         register_unary_op(details::e_log10 , details::log10_op)
         register_unary_op(details::e_log2  , details::log2_op )
         register_unary_op(details::e_log1p , details::log1p_op)
         register_unary_op(details::e_neg   , details::neg_op  )
         register_unary_op(details::e_pos   , details::pos_op  )
         register_unary_op(details::e_round , details::round_op)
         register_unary_op(details::e_sin   , details::sin_op  )
         register_unary_op(details::e_sinc  , details::sinc_op )
         register_unary_op(details::e_sinh  , details::sinh_op )
         register_unary_op(details::e_sqrt  , details::sqrt_op )
         register_unary_op(details::e_tan   , details::tan_op  )
         register_unary_op(details::e_tanh  , details::tanh_op )
         register_unary_op(details::e_cot   , details::cot_op  )
         register_unary_op(details::e_sec   , details::sec_op  )
         register_unary_op(details::e_csc   , details::csc_op  )
         register_unary_op(details::e_r2d   , details::r2d_op  )
         register_unary_op(details::e_d2r   , details::d2r_op  )
         register_unary_op(details::e_d2g   , details::d2g_op  )
         register_unary_op(details::e_g2d   , details::g2d_op  )
         register_unary_op(details::e_notl  , details::notl_op )
         register_unary_op(details::e_sgn   , details::sgn_op  )
         register_unary_op(details::e_erf   , details::erf_op  )
         register_unary_op(details::e_erfc  , details::erfc_op )
         register_unary_op(details::e_ncdf  , details::ncdf_op )
         register_unary_op(details::e_frac  , details::frac_op )
         register_unary_op(details::e_trunc , details::trunc_op)
         #undef register_unary_op
      }
 
      inline void load_binary_operations_map(binary_op_map_t& m)
      {
         typedef typename binary_op_map_t::value_type value_type;
 
         #define register_binary_op(Op, BinaryFunctor)       \
         m.insert(value_type(Op,BinaryFunctor<T>::process)); \
 
         register_binary_op(details::e_add  , details::add_op )
         register_binary_op(details::e_sub  , details::sub_op )
         register_binary_op(details::e_mul  , details::mul_op )
         register_binary_op(details::e_div  , details::div_op )
         register_binary_op(details::e_mod  , details::mod_op )
         register_binary_op(details::e_pow  , details::pow_op )
         register_binary_op(details::e_lt   , details::lt_op  )
         register_binary_op(details::e_lte  , details::lte_op )
         register_binary_op(details::e_gt   , details::gt_op  )
         register_binary_op(details::e_gte  , details::gte_op )
         register_binary_op(details::e_eq   , details::eq_op  )
         register_binary_op(details::e_ne   , details::ne_op  )
         register_binary_op(details::e_and  , details::and_op )
         register_binary_op(details::e_nand , details::nand_op)
         register_binary_op(details::e_or   , details::or_op  )
         register_binary_op(details::e_nor  , details::nor_op )
         register_binary_op(details::e_xor  , details::xor_op )
         register_binary_op(details::e_xnor , details::xnor_op)
         #undef register_binary_op
      }
 
      inline void load_inv_binary_operations_map(inv_binary_op_map_t& m)
      {
         typedef typename inv_binary_op_map_t::value_type value_type;
 
         #define register_binary_op(Op, BinaryFunctor)       \
         m.insert(value_type(BinaryFunctor<T>::process,Op)); \
 
         register_binary_op(details::e_add  , details::add_op )
         register_binary_op(details::e_sub  , details::sub_op )
         register_binary_op(details::e_mul  , details::mul_op )
         register_binary_op(details::e_div  , details::div_op )
         register_binary_op(details::e_mod  , details::mod_op )
         register_binary_op(details::e_pow  , details::pow_op )
         register_binary_op(details::e_lt   , details::lt_op  )
         register_binary_op(details::e_lte  , details::lte_op )
         register_binary_op(details::e_gt   , details::gt_op  )
         register_binary_op(details::e_gte  , details::gte_op )
         register_binary_op(details::e_eq   , details::eq_op  )
         register_binary_op(details::e_ne   , details::ne_op  )
         register_binary_op(details::e_and  , details::and_op )
         register_binary_op(details::e_nand , details::nand_op)
         register_binary_op(details::e_or   , details::or_op  )
         register_binary_op(details::e_nor  , details::nor_op )
         register_binary_op(details::e_xor  , details::xor_op )
         register_binary_op(details::e_xnor , details::xnor_op)
         #undef register_binary_op
      }
 
      inline void load_sf3_map(sf3_map_t& sf3_map)
      {
         typedef std::pair<trinary_functor_t,details::operator_type> pair_t;
 
         #define register_sf3(Op)                                                                             \
         sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
 
         register_sf3(00) register_sf3(01) register_sf3(02) register_sf3(03)
         register_sf3(04) register_sf3(05) register_sf3(06) register_sf3(07)
         register_sf3(08) register_sf3(09) register_sf3(10) register_sf3(11)
         register_sf3(12) register_sf3(13) register_sf3(14) register_sf3(15)
         register_sf3(16) register_sf3(17) register_sf3(18) register_sf3(19)
         register_sf3(20) register_sf3(21) register_sf3(22) register_sf3(23)
         register_sf3(24) register_sf3(25) register_sf3(26) register_sf3(27)
         register_sf3(28) register_sf3(29) register_sf3(30)
         #undef register_sf3
 
         #define register_sf3_extid(Id, Op)                                        \
         sf3_map[Id] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
 
         register_sf3_extid("(t-t)-t",23)  // (t-t)-t --> t-(t+t)
         #undef register_sf3_extid
      }
 
      inline void load_sf4_map(sf4_map_t& sf4_map)
      {
         typedef std::pair<quaternary_functor_t,details::operator_type> pair_t;
 
         #define register_sf4(Op)                                                                             \
         sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
 
         register_sf4(48) register_sf4(49) register_sf4(50) register_sf4(51)
         register_sf4(52) register_sf4(53) register_sf4(54) register_sf4(55)
         register_sf4(56) register_sf4(57) register_sf4(58) register_sf4(59)
         register_sf4(60) register_sf4(61) register_sf4(62) register_sf4(63)
         register_sf4(64) register_sf4(65) register_sf4(66) register_sf4(67)
         register_sf4(68) register_sf4(69) register_sf4(70) register_sf4(71)
         register_sf4(72) register_sf4(73) register_sf4(74) register_sf4(75)
         register_sf4(76) register_sf4(77) register_sf4(78) register_sf4(79)
         register_sf4(80) register_sf4(81) register_sf4(82) register_sf4(83)
         #undef register_sf4
 
         #define register_sf4ext(Op)                                                                                    \
         sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \
 
         register_sf4ext(00) register_sf4ext(01) register_sf4ext(02) register_sf4ext(03)
         register_sf4ext(04) register_sf4ext(05) register_sf4ext(06) register_sf4ext(07)
         register_sf4ext(08) register_sf4ext(09) register_sf4ext(10) register_sf4ext(11)
         register_sf4ext(12) register_sf4ext(13) register_sf4ext(14) register_sf4ext(15)
         register_sf4ext(16) register_sf4ext(17) register_sf4ext(18) register_sf4ext(19)
         register_sf4ext(20) register_sf4ext(21) register_sf4ext(22) register_sf4ext(23)
         register_sf4ext(24) register_sf4ext(25) register_sf4ext(26) register_sf4ext(27)
         register_sf4ext(28) register_sf4ext(29) register_sf4ext(30) register_sf4ext(31)
         register_sf4ext(32) register_sf4ext(33) register_sf4ext(34) register_sf4ext(35)
         register_sf4ext(36) register_sf4ext(36) register_sf4ext(38) register_sf4ext(39)
         register_sf4ext(40) register_sf4ext(41) register_sf4ext(42) register_sf4ext(43)
         register_sf4ext(44) register_sf4ext(45) register_sf4ext(46) register_sf4ext(47)
         register_sf4ext(48) register_sf4ext(49) register_sf4ext(50) register_sf4ext(51)
         register_sf4ext(52) register_sf4ext(53) register_sf4ext(54) register_sf4ext(55)
         register_sf4ext(56) register_sf4ext(57) register_sf4ext(58) register_sf4ext(59)
         register_sf4ext(60) register_sf4ext(61)
         #undef register_sf4ext
      }
 
      inline results_context_t& results_ctx()
      {
         if (0 == results_context_)
         {
            results_context_ = new results_context_t();
         }
 
         return (*results_context_);
      }
 
      inline void return_cleanup()
      {
         #ifndef exprtk_disable_return_statement
         if (results_context_)
         {
            delete results_context_;
            results_context_ = 0;
         }
 
         state_.return_stmt_present = false;
         #endif
      }
 
   private:
 
      parser(const parser<T>&) exprtk_delete;
      parser<T>& operator=(const parser<T>&) exprtk_delete;
 
      settings_store settings_;
      expression_generator<T> expression_generator_;
      details::node_allocator node_allocator_;
      symtab_store symtab_store_;
      dependent_entity_collector dec_;
      std::deque<parser_error::type> error_list_;
      std::deque<bool> brkcnt_list_;
      parser_state state_;
      bool resolve_unknown_symbol_;
      results_context_t* results_context_;
      unknown_symbol_resolver* unknown_symbol_resolver_;
      unknown_symbol_resolver default_usr_;
      base_ops_map_t base_ops_map_;
      unary_op_map_t unary_op_map_;
      binary_op_map_t binary_op_map_;
      inv_binary_op_map_t inv_binary_op_map_;
      sf3_map_t sf3_map_;
      sf4_map_t sf4_map_;
      std::string synthesis_error_;
      scope_element_manager sem_;
      std::vector<state_t> current_state_stack_;
 
      immutable_memory_map_t immutable_memory_map_;
      immutable_symtok_map_t immutable_symtok_map_;
 
      lexer::helper::helper_assembly helper_assembly_;
 
      lexer::helper::commutative_inserter       commutative_inserter_;
      lexer::helper::operator_joiner            operator_joiner_2_;
      lexer::helper::operator_joiner            operator_joiner_3_;
      lexer::helper::symbol_replacer            symbol_replacer_;
      lexer::helper::bracket_checker            bracket_checker_;
      lexer::helper::numeric_checker<T>         numeric_checker_;
      lexer::helper::sequence_validator         sequence_validator_;
      lexer::helper::sequence_validator_3tokens sequence_validator_3tkns_;
 
      loop_runtime_check_ptr          loop_runtime_check_;
      vector_access_runtime_check_ptr vector_access_runtime_check_;
      compilation_check_ptr           compilation_check_ptr_;
 
      template <typename ParserType>
      friend void details::disable_type_checking(ParserType& p);
   }; // class parser
 
   namespace details
   {
      template <typename T>
      struct collector_helper
      {
         typedef exprtk::symbol_table<T> symbol_table_t;
         typedef exprtk::expression<T>   expression_t;
         typedef exprtk::parser<T>       parser_t;
         typedef typename parser_t::dependent_entity_collector::symbol_t symbol_t;
         typedef typename parser_t::unknown_symbol_resolver usr_t;
 
         struct resolve_as_vector : public parser_t::unknown_symbol_resolver
         {
            typedef exprtk::parser<T> parser_t;
 
            resolve_as_vector()
            : usr_t(usr_t::e_usrmode_extended)
            {}
 
            virtual bool process(const std::string& unknown_symbol,
                                 symbol_table_t& symbol_table,
                                 std::string&)
            {
               static T v[1];
               symbol_table.add_vector(unknown_symbol,v);
               return true;
            }
         };
 
         static inline bool collection_pass(const std::string& expression_string,
                                            std::set<std::string>& symbol_set,
                                            const bool collect_variables,
                                            const bool collect_functions,
                                            const bool vector_pass,
                                            symbol_table_t& ext_symbol_table)
         {
            symbol_table_t symbol_table;
            expression_t   expression;
            parser_t       parser;
 
            resolve_as_vector vect_resolver;
 
            expression.register_symbol_table(symbol_table    );
            expression.register_symbol_table(ext_symbol_table);
 
            if (vector_pass)
               parser.enable_unknown_symbol_resolver(&vect_resolver);
            else
               parser.enable_unknown_symbol_resolver();
 
            if (collect_variables)
               parser.dec().collect_variables() = true;
 
            if (collect_functions)
               parser.dec().collect_functions() = true;
 
            bool pass_result = false;
 
            details::disable_type_checking(parser);
 
            if (parser.compile(expression_string, expression))
            {
               pass_result = true;
 
               std::deque<symbol_t> symb_list;
               parser.dec().symbols(symb_list);
 
               for (std::size_t i = 0; i < symb_list.size(); ++i)
               {
                  symbol_set.insert(symb_list[i].first);
               }
            }
 
            return pass_result;
         }
      };
   }
 
   template <typename Allocator,
             template <typename, typename> class Sequence>
   inline bool collect_variables(const std::string& expression,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef double T;
      typedef details::collector_helper<T> collect_t;
 
      collect_t::symbol_table_t null_symbol_table;
 
      std::set<std::string> symbol_set;
 
      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, true, false, false, null_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, true, false,  true, null_symbol_table);
 
      if (!variable_pass && !vector_pass)
         return false;
 
      std::set<std::string>::iterator itr = symbol_set.begin();
 
      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }
 
      return true;
   }
 
   template <typename T,
             typename Allocator,
             template <typename, typename> class Sequence>
   inline bool collect_variables(const std::string& expression,
                                 exprtk::symbol_table<T>& extrnl_symbol_table,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef details::collector_helper<T> collect_t;
 
      std::set<std::string> symbol_set;
 
      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, true, false, false, extrnl_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, true, false,  true, extrnl_symbol_table);
 
      if (!variable_pass && !vector_pass)
         return false;
 
      std::set<std::string>::iterator itr = symbol_set.begin();
 
      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }
 
      return true;
   }
 
   template <typename Allocator,
             template <typename, typename> class Sequence>
   inline bool collect_functions(const std::string& expression,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef double T;
      typedef details::collector_helper<T> collect_t;
 
      collect_t::symbol_table_t null_symbol_table;
 
      std::set<std::string> symbol_set;
 
      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, false, true, false, null_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, false, true,  true, null_symbol_table);
 
      if (!variable_pass && !vector_pass)
         return false;
 
      std::set<std::string>::iterator itr = symbol_set.begin();
 
      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }
 
      return true;
   }
 
   template <typename T,
             typename Allocator,
             template <typename, typename> class Sequence>
   inline bool collect_functions(const std::string& expression,
                                 exprtk::symbol_table<T>& extrnl_symbol_table,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef details::collector_helper<T> collect_t;
 
      std::set<std::string> symbol_set;
 
      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, false, true, false, extrnl_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, false, true,  true, extrnl_symbol_table);
 
      if (!variable_pass && !vector_pass)
         return false;
 
      std::set<std::string>::iterator itr = symbol_set.begin();
 
      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }
 
      return true;
   }
 
   template <typename T>
   inline T integrate(const expression<T>& e,
                      T& x,
                      const T& r0, const T& r1,
                      const std::size_t number_of_intervals = 1000000)
   {
      if (r0 > r1)
         return T(0);
 
      const T h = (r1 - r0) / (T(2) * number_of_intervals);
      T total_area = T(0);
 
      for (std::size_t i = 0; i < number_of_intervals; ++i)
      {
         x = r0 + T(2) * i * h;
         const T y0 = e.value(); x += h;
         const T y1 = e.value(); x += h;
         const T y2 = e.value(); x += h;
         total_area += h * (y0 + T(4) * y1 + y2) / T(3);
      }
 
      return total_area;
   }
 
   template <typename T>
   inline T integrate(const expression<T>& e,
                      const std::string& variable_name,
                      const T& r0, const T& r1,
                      const std::size_t number_of_intervals = 1000000)
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();
 
      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
 
      details::variable_node<T>* var = sym_table.get_variable(variable_name);
 
      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = integrate(e, x, r0, r1, number_of_intervals);
         x = x_original;
 
         return result;
      }
 
      return std::numeric_limits<T>::quiet_NaN();
   }
 
   template <typename T>
   inline T derivative(const expression<T>& e,
                       T& x,
                       const T& h = T(0.00000001))
   {
      const T x_init = x;
      const T _2h    = T(2) * h;
 
      x = x_init + _2h;
      const T y0 = e.value();
      x = x_init + h;
      const T y1 = e.value();
      x = x_init - h;
      const T y2 = e.value();
      x = x_init - _2h;
      const T y3 = e.value();
      x = x_init;
 
      return (-y0 + T(8) * (y1 - y2) + y3) / (T(12) * h);
   }
 
   template <typename T>
   inline T second_derivative(const expression<T>& e,
                              T& x,
                              const T& h = T(0.00001))
   {
      const T x_init = x;
      const T _2h    = T(2) * h;
 
      const T y = e.value();
      x = x_init + _2h;
      const T y0 = e.value();
      x = x_init + h;
      const T y1 = e.value();
      x = x_init - h;
      const T y2 = e.value();
      x = x_init - _2h;
      const T y3 = e.value();
      x = x_init;
 
      return (-y0 + T(16) * (y1 + y2) - T(30) * y - y3) / (T(12) * h * h);
   }
 
   template <typename T>
   inline T third_derivative(const expression<T>& e,
                             T& x,
                             const T& h = T(0.0001))
   {
      const T x_init = x;
      const T _2h    = T(2) * h;
 
      x = x_init + _2h;
      const T y0 = e.value();
      x = x_init + h;
      const T y1 = e.value();
      x = x_init - h;
      const T y2 = e.value();
      x = x_init - _2h;
      const T y3 = e.value();
      x = x_init;
 
      return (y0 + T(2) * (y2 - y1) - y3) / (T(2) * h * h * h);
   }
 
   template <typename T>
   inline T derivative(const expression<T>& e,
                       const std::string& variable_name,
                       const T& h = T(0.00000001))
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();
 
      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
 
      details::variable_node<T>* var = sym_table.get_variable(variable_name);
 
      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = derivative(e, x, h);
         x = x_original;
 
         return result;
      }
 
      return std::numeric_limits<T>::quiet_NaN();
   }
 
   template <typename T>
   inline T second_derivative(const expression<T>& e,
                              const std::string& variable_name,
                              const T& h = T(0.00001))
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();
 
      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
 
      details::variable_node<T>* var = sym_table.get_variable(variable_name);
 
      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = second_derivative(e, x, h);
         x = x_original;
 
         return result;
      }
 
      return std::numeric_limits<T>::quiet_NaN();
   }
 
   template <typename T>
   inline T third_derivative(const expression<T>& e,
                             const std::string& variable_name,
                             const T& h = T(0.0001))
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();
 
      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
 
      details::variable_node<T>* var = sym_table.get_variable(variable_name);
 
      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = third_derivative(e, x, h);
         x = x_original;
 
         return result;
      }
 
      return std::numeric_limits<T>::quiet_NaN();
   }
 
   /*
      Note: The following 'compute' routines are simple helpers,
      for quickly setting up the required pieces of code in order
      to evaluate an expression. By virtue of how they operate
      there will be an overhead with regards to their setup and
      teardown and hence should not be used in time critical
      sections of code.
      Furthermore they only assume a small sub set of variables,
      no string variables or user defined functions.
   */
   template <typename T>
   inline bool compute(const std::string& expression_string, T& result)
   {
      // No variables
      symbol_table<T> symbol_table;
      symbol_table.add_constants();
 
      expression<T> expression;
      expression.register_symbol_table(symbol_table);
 
      parser<T> parser;
 
      if (parser.compile(expression_string,expression))
      {
         result = expression.value();
 
         return true;
      }
      else
         return false;
   }
 
   template <typename T>
   inline bool compute(const std::string& expression_string,
                       const T& x,
                       T& result)
   {
      // Only 'x'
      static const std::string x_var("x");
 
      symbol_table<T> symbol_table;
      symbol_table.add_constants();
      symbol_table.add_constant(x_var,x);
 
      expression<T> expression;
      expression.register_symbol_table(symbol_table);
 
      parser<T> parser;
 
      if (parser.compile(expression_string,expression))
      {
         result = expression.value();
 
         return true;
      }
      else
         return false;
   }
 
   template <typename T>
   inline bool compute(const std::string& expression_string,
                       const T&x, const T& y,
                       T& result)
   {
      // Only 'x' and 'y'
      static const std::string x_var("x");
      static const std::string y_var("y");
 
      symbol_table<T> symbol_table;
      symbol_table.add_constants();
      symbol_table.add_constant(x_var,x);
      symbol_table.add_constant(y_var,y);
 
      expression<T> expression;
      expression.register_symbol_table(symbol_table);
 
      parser<T> parser;
 
      if (parser.compile(expression_string,expression))
      {
         result = expression.value();
 
         return true;
      }
      else
         return false;
   }
 
   template <typename T>
   inline bool compute(const std::string& expression_string,
                       const T& x, const T& y, const T& z,
                       T& result)
   {
      // Only 'x', 'y' or 'z'
      static const std::string x_var("x");
      static const std::string y_var("y");
      static const std::string z_var("z");
 
      symbol_table<T> symbol_table;
      symbol_table.add_constants();
      symbol_table.add_constant(x_var,x);
      symbol_table.add_constant(y_var,y);
      symbol_table.add_constant(z_var,z);
 
      expression<T> expression;
      expression.register_symbol_table(symbol_table);
 
      parser<T> parser;
 
      if (parser.compile(expression_string,expression))
      {
         result = expression.value();
 
         return true;
      }
      else
         return false;
   }
 
   template <typename T, std::size_t N>
   class polynomial : public ifunction<T>
   {
   private:
 
      template <typename Type, std::size_t NumberOfCoefficients>
      struct poly_impl { };
 
      template <typename Type>
      struct poly_impl <Type,12>
      {
         static inline T evaluate(const Type x,
                                  const Type c12, const Type c11, const Type c10, const Type c9, const Type c8,
                                  const Type  c7, const Type  c6, const Type  c5, const Type c4, const Type c3,
                                  const Type  c2, const Type  c1, const Type  c0)
         {
            // p(x) = c_12x^12 + c_11x^11 + c_10x^10 + c_9x^9 + c_8x^8 + c_7x^7 + c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return ((((((((((((c12 * x + c11) * x + c10) * x + c9) * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,11>
      {
         static inline T evaluate(const Type x,
                                  const Type c11, const Type c10, const Type c9, const Type c8, const Type c7,
                                  const Type c6,  const Type  c5, const Type c4, const Type c3, const Type c2,
                                  const Type c1,  const Type  c0)
         {
            // p(x) = c_11x^11 + c_10x^10 + c_9x^9 + c_8x^8 + c_7x^7 + c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return (((((((((((c11 * x + c10) * x + c9) * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,10>
      {
         static inline T evaluate(const Type x,
                                  const Type c10, const Type c9, const Type c8, const Type c7, const Type c6,
                                  const Type c5,  const Type c4, const Type c3, const Type c2, const Type c1,
                                  const Type c0)
         {
            // p(x) = c_10x^10 + c_9x^9 + c_8x^8 + c_7x^7 + c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return ((((((((((c10 * x + c9) * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,9>
      {
         static inline T evaluate(const Type x,
                                  const Type c9, const Type c8, const Type c7, const Type c6, const Type c5,
                                  const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
         {
            // p(x) = c_9x^9 + c_8x^8 + c_7x^7 + c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return (((((((((c9 * x + c8) * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,8>
      {
         static inline T evaluate(const Type x,
                                  const Type c8, const Type c7, const Type c6, const Type c5, const Type c4,
                                  const Type c3, const Type c2, const Type c1, const Type c0)
         {
            // p(x) = c_8x^8 + c_7x^7 + c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return ((((((((c8 * x + c7) * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,7>
      {
         static inline T evaluate(const Type x,
                                  const Type c7, const Type c6, const Type c5, const Type c4, const Type c3,
                                  const Type c2, const Type c1, const Type c0)
         {
            // p(x) = c_7x^7 + c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return (((((((c7 * x + c6) * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,6>
      {
         static inline T evaluate(const Type x,
                                  const Type c6, const Type c5, const Type c4, const Type c3, const Type c2,
                                  const Type c1, const Type c0)
         {
            // p(x) = c_6x^6 + c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return ((((((c6 * x + c5) * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,5>
      {
         static inline T evaluate(const Type x,
                                  const Type c5, const Type c4, const Type c3, const Type c2,
                                  const Type c1, const Type c0)
         {
            // p(x) = c_5x^5 + c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return (((((c5 * x + c4) * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,4>
      {
         static inline T evaluate(const Type x, const Type c4, const Type c3, const Type c2, const Type c1, const Type c0)
         {
            // p(x) = c_4x^4 + c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return ((((c4 * x + c3) * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,3>
      {
         static inline T evaluate(const Type x, const Type c3, const Type c2, const Type c1, const Type c0)
         {
            // p(x) = c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0
            return (((c3 * x + c2) * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,2>
      {
         static inline T evaluate(const Type x, const Type c2, const Type c1, const Type c0)
         {
            // p(x) = c_2x^2 + c_1x^1 + c_0x^0
            return ((c2 * x + c1) * x + c0);
         }
      };
 
      template <typename Type>
      struct poly_impl <Type,1>
      {
         static inline T evaluate(const Type x, const Type c1, const Type c0)
         {
            // p(x) = c_1x^1 + c_0x^0
            return (c1 * x + c0);
         }
      };
 
   public:
 
      using ifunction<T>::operator();
 
      polynomial()
      : ifunction<T>((N+2 <= 20) ? (N + 2) : std::numeric_limits<std::size_t>::max())
      {
         disable_has_side_effects(*this);
      }
 
      virtual ~polynomial()
      {}
 
      #define poly_rtrn(NN) \
      return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :
 
      inline virtual T operator() (const T& x, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(1) (poly_impl<T,1>::evaluate(x, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(2) (poly_impl<T,2>::evaluate(x, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c3, const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(3) (poly_impl<T,3>::evaluate(x, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c4, const T& c3, const T& c2, const T& c1,
                                   const T& c0) exprtk_override
      {
         poly_rtrn(4) (poly_impl<T,4>::evaluate(x, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c5, const T& c4, const T& c3, const T& c2,
                                   const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(5) (poly_impl<T,5>::evaluate(x, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c6, const T& c5, const T& c4, const T& c3,
                                   const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(6) (poly_impl<T,6>::evaluate(x, c6, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c7, const T& c6, const T& c5, const T& c4,
                                   const T& c3, const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(7) (poly_impl<T,7>::evaluate(x, c7, c6, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c8, const T& c7, const T& c6, const T& c5,
                                   const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(8) (poly_impl<T,8>::evaluate(x, c8, c7, c6, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c9, const T& c8, const T& c7, const T& c6,
                                   const T& c5, const T& c4, const T& c3, const T& c2, const T& c1,
                                   const T& c0) exprtk_override
      {
         poly_rtrn(9) (poly_impl<T,9>::evaluate(x, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c10, const T& c9, const T& c8, const T& c7,
                                   const T& c6, const T& c5, const T& c4, const T& c3, const T& c2,
                                   const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(10) (poly_impl<T,10>::evaluate(x, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c11, const T& c10, const T& c9, const T& c8,
                                   const T& c7, const T& c6, const T& c5, const T& c4, const T& c3,
                                   const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(11) (poly_impl<T,11>::evaluate(x, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0));
      }
 
      inline virtual T operator() (const T& x, const T& c12, const T& c11, const T& c10, const T& c9,
                                   const T& c8, const T& c7, const T& c6, const T& c5, const T& c4,
                                   const T& c3, const T& c2, const T& c1, const T& c0) exprtk_override
      {
         poly_rtrn(12) (poly_impl<T,12>::evaluate(x, c12, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0));
      }
 
      #undef poly_rtrn
 
      inline virtual T operator() () exprtk_override
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
 
      inline virtual T operator() (const T&) exprtk_override
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
 
      inline virtual T operator() (const T&, const T&) exprtk_override
      {
         return std::numeric_limits<T>::quiet_NaN();
      }
   };
 
   template <typename T>
   class function_compositor
   {
   public:
 
      typedef exprtk::expression<T>             expression_t;
      typedef exprtk::symbol_table<T>           symbol_table_t;
      typedef exprtk::parser<T>                 parser_t;
      typedef typename parser_t::settings_store settings_t;
 
      struct function
      {
         function()
         {}
 
         function(const std::string& n)
         : name_(n)
         {}
 
         function(const std::string& name,
                  const std::string& expression)
         : name_(name)
         , expression_(expression)
         {}
 
         function(const std::string& name,
                  const std::string& expression,
                  const std::string& v0)
         : name_(name)
         , expression_(expression)
         {
            v_.push_back(v0);
         }
 
         function(const std::string& name,
                  const std::string& expression,
                  const std::string& v0, const std::string& v1)
         : name_(name)
         , expression_(expression)
         {
            v_.push_back(v0); v_.push_back(v1);
         }
 
         function(const std::string& name,
                  const std::string& expression,
                  const std::string& v0, const std::string& v1,
                  const std::string& v2)
         : name_(name)
         , expression_(expression)
         {
            v_.push_back(v0); v_.push_back(v1);
            v_.push_back(v2);
         }
 
         function(const std::string& name,
                  const std::string& expression,
                  const std::string& v0, const std::string& v1,
                  const std::string& v2, const std::string& v3)
         : name_(name)
         , expression_(expression)
         {
            v_.push_back(v0); v_.push_back(v1);
            v_.push_back(v2); v_.push_back(v3);
         }
 
         function(const std::string& name,
                  const std::string& expression,
                  const std::string& v0, const std::string& v1,
                  const std::string& v2, const std::string& v3,
                  const std::string& v4)
         : name_(name)
         , expression_(expression)
         {
            v_.push_back(v0); v_.push_back(v1);
            v_.push_back(v2); v_.push_back(v3);
            v_.push_back(v4);
         }
 
         inline function& name(const std::string& n)
         {
            name_ = n;
            return (*this);
         }
 
         inline function& expression(const std::string& e)
         {
            expression_ = e;
            return (*this);
         }
 
         inline function& var(const std::string& v)
         {
            v_.push_back(v);
            return (*this);
         }
 
         inline function& vars(const std::string& v0,
                               const std::string& v1)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            return (*this);
         }
 
         inline function& vars(const std::string& v0,
                               const std::string& v1,
                               const std::string& v2)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            v_.push_back(v2);
            return (*this);
         }
 
         inline function& vars(const std::string& v0,
                               const std::string& v1,
                               const std::string& v2,
                               const std::string& v3)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            v_.push_back(v2);
            v_.push_back(v3);
            return (*this);
         }
 
         inline function& vars(const std::string& v0,
                               const std::string& v1,
                               const std::string& v2,
                               const std::string& v3,
                               const std::string& v4)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            v_.push_back(v2);
            v_.push_back(v3);
            v_.push_back(v4);
            return (*this);
         }
 
         std::string name_;
         std::string expression_;
         std::deque<std::string> v_;
      };
 
   private:
 
      struct base_func : public exprtk::ifunction<T>
      {
         typedef const T&                       type;
         typedef exprtk::ifunction<T>     function_t;
         typedef std::vector<T*>            varref_t;
         typedef std::vector<T>                var_t;
         typedef std::pair<T*,std::size_t> lvarref_t;
         typedef std::vector<lvarref_t>    lvr_vec_t;
 
         using exprtk::ifunction<T>::operator();
 
         base_func(const std::size_t& pc = 0)
         : exprtk::ifunction<T>(pc)
         , local_var_stack_size(0)
         , stack_depth(0)
         {
            v.resize(pc);
         }
 
         virtual ~base_func()
         {}
 
         #define exprtk_assign(Index) \
         (*v[Index]) = v##Index;      \
 
         inline void update(const T& v0)
         {
            exprtk_assign(0)
         }
 
         inline void update(const T& v0, const T& v1)
         {
            exprtk_assign(0) exprtk_assign(1)
         }
 
         inline void update(const T& v0, const T& v1, const T& v2)
         {
            exprtk_assign(0) exprtk_assign(1)
            exprtk_assign(2)
         }
 
         inline void update(const T& v0, const T& v1, const T& v2, const T& v3)
         {
            exprtk_assign(0) exprtk_assign(1)
            exprtk_assign(2) exprtk_assign(3)
         }
 
         inline void update(const T& v0, const T& v1, const T& v2, const T& v3, const T& v4)
         {
            exprtk_assign(0) exprtk_assign(1)
            exprtk_assign(2) exprtk_assign(3)
            exprtk_assign(4)
         }
 
         inline void update(const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5)
         {
            exprtk_assign(0) exprtk_assign(1)
            exprtk_assign(2) exprtk_assign(3)
            exprtk_assign(4) exprtk_assign(5)
         }
 
         #ifdef exprtk_assign
         #undef exprtk_assign
         #endif
 
         inline function_t& setup(expression_t& expr)
         {
            expression = expr;
 
            typedef typename expression_t::control_block::local_data_list_t ldl_t;
 
            const ldl_t ldl = expr.local_data_list();
 
            std::vector<std::size_t> index_list;
 
            for (std::size_t i = 0; i < ldl.size(); ++i)
            {
               if (ldl[i].size)
               {
                  index_list.push_back(i);
               }
            }
 
            std::size_t input_param_count = 0;
 
            for (std::size_t i = 0; i < index_list.size(); ++i)
            {
               const std::size_t index = index_list[i];
 
               if (i < (index_list.size() - v.size()))
               {
                  lv.push_back(
                        std::make_pair(
                           reinterpret_cast<T*>(ldl[index].pointer),
                           ldl[index].size));
 
                  local_var_stack_size += ldl[index].size;
               }
               else
                  v[input_param_count++] = reinterpret_cast<T*>(ldl[index].pointer);
            }
 
            clear_stack();
 
            return (*this);
         }
 
         inline void pre()
         {
            if (stack_depth++)
            {
               if (!v.empty())
               {
                  var_t var_stack(v.size(),T(0));
                  copy(v,var_stack);
                  param_stack.push_back(var_stack);
               }
 
               if (!lv.empty())
               {
                  var_t local_var_stack(local_var_stack_size,T(0));
                  copy(lv,local_var_stack);
                  local_stack.push_back(local_var_stack);
               }
            }
         }
 
         inline void post()
         {
            if (--stack_depth)
            {
               if (!v.empty())
               {
                  copy(param_stack.back(),v);
                  param_stack.pop_back();
               }
 
               if (!lv.empty())
               {
                  copy(local_stack.back(),lv);
                  local_stack.pop_back();
               }
            }
         }
 
         void copy(const varref_t& src_v, var_t& dest_v)
         {
            for (std::size_t i = 0; i < src_v.size(); ++i)
            {
               dest_v[i] = (*src_v[i]);
            }
         }
 
         void copy(const var_t& src_v, varref_t& dest_v)
         {
            for (std::size_t i = 0; i < src_v.size(); ++i)
            {
               (*dest_v[i]) = src_v[i];
            }
         }
 
         void copy(const lvr_vec_t& src_v, var_t& dest_v)
         {
            typename var_t::iterator itr = dest_v.begin();
            typedef  typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;
 
            for (std::size_t i = 0; i < src_v.size(); ++i)
            {
               lvarref_t vr = src_v[i];
 
               if (1 == vr.second)
                  *itr++ = (*vr.first);
               else
               {
                  std::copy(vr.first, vr.first + vr.second, itr);
                  itr += static_cast<diff_t>(vr.second);
               }
            }
         }
 
         void copy(const var_t& src_v, lvr_vec_t& dest_v)
         {
            typename var_t::const_iterator itr = src_v.begin();
            typedef  typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;
 
            for (std::size_t i = 0; i < src_v.size(); ++i)
            {
               lvarref_t vr = dest_v[i];
 
               if (1 == vr.second)
                  (*vr.first) = *itr++;
               else
               {
                  std::copy(itr, itr + static_cast<diff_t>(vr.second), vr.first);
                  itr += static_cast<diff_t>(vr.second);
               }
            }
         }
 
         inline void clear_stack()
         {
            for (std::size_t i = 0; i < v.size(); ++i)
            {
               (*v[i]) = 0;
            }
         }
 
         inline virtual T value(expression_t& e)
         {
            return e.value();
         }
 
         expression_t expression;
         varref_t v;
         lvr_vec_t lv;
         std::size_t local_var_stack_size;
         std::size_t stack_depth;
         std::deque<var_t> param_stack;
         std::deque<var_t> local_stack;
      };
 
      typedef std::map<std::string,base_func*> funcparam_t;
 
      struct func_0param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_0param() : base_func(0) {}
 
         inline T operator() () exprtk_override
         {
            return this->value(base_func::expression);
         }
      };
 
      typedef const T& type;
 
      template <typename BaseFuncType>
      struct scoped_bft
      {
         explicit scoped_bft(BaseFuncType& bft)
         : bft_(bft)
         {
            bft_.pre ();
         }
 
        ~scoped_bft()
         {
            bft_.post();
         }
 
         BaseFuncType& bft_;
 
      private:
 
         scoped_bft(const scoped_bft&) exprtk_delete;
         scoped_bft& operator=(const scoped_bft&) exprtk_delete;
      };
 
      struct func_1param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_1param() : base_func(1) {}
 
         inline T operator() (type v0) exprtk_override
         {
            scoped_bft<func_1param> sb(*this);
            base_func::update(v0);
            return this->value(base_func::expression);
         }
      };
 
      struct func_2param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_2param() : base_func(2) {}
 
         inline T operator() (type v0, type v1) exprtk_override
         {
            scoped_bft<func_2param> sb(*this);
            base_func::update(v0, v1);
            return this->value(base_func::expression);
         }
      };
 
      struct func_3param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_3param() : base_func(3) {}
 
         inline T operator() (type v0, type v1, type v2) exprtk_override
         {
            scoped_bft<func_3param> sb(*this);
            base_func::update(v0, v1, v2);
            return this->value(base_func::expression);
         }
      };
 
      struct func_4param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_4param() : base_func(4) {}
 
         inline T operator() (type v0, type v1, type v2, type v3) exprtk_override
         {
            scoped_bft<func_4param> sb(*this);
            base_func::update(v0, v1, v2, v3);
            return this->value(base_func::expression);
         }
      };
 
      struct func_5param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_5param() : base_func(5) {}
 
         inline T operator() (type v0, type v1, type v2, type v3, type v4) exprtk_override
         {
            scoped_bft<func_5param> sb(*this);
            base_func::update(v0, v1, v2, v3, v4);
            return this->value(base_func::expression);
         }
      };
 
      struct func_6param : public base_func
      {
         using exprtk::ifunction<T>::operator();
 
         func_6param() : base_func(6) {}
 
         inline T operator() (type v0, type v1, type v2, type v3, type v4, type v5) exprtk_override
         {
            scoped_bft<func_6param> sb(*this);
            base_func::update(v0, v1, v2, v3, v4, v5);
            return this->value(base_func::expression);
         }
      };
 
      static T return_value(expression_t& e)
      {
         typedef exprtk::results_context<T> results_context_t;
         typedef typename results_context_t::type_store_t type_t;
         typedef typename type_t::scalar_view scalar_t;
 
         const T result = e.value();
 
         if (e.return_invoked())
         {
            // Due to the post compilation checks, it can be safely
            // assumed that there will be at least one parameter
            // and that the first parameter will always be scalar.
            return scalar_t(e.results()[0])();
         }
 
         return result;
      }
 
      #define def_fp_retval(N)                                            \
      struct func_##N##param_retval exprtk_final : public func_##N##param \
      {                                                                   \
         inline T value(expression_t& e) exprtk_override                  \
         {                                                                \
            return return_value(e);                                       \
         }                                                                \
      };                                                                  \
 
      def_fp_retval(0)
      def_fp_retval(1)
      def_fp_retval(2)
      def_fp_retval(3)
      def_fp_retval(4)
      def_fp_retval(5)
      def_fp_retval(6)
 
      template <typename Allocator,
                template <typename, typename> class Sequence>
      inline bool add(const std::string& name,
                      const std::string& expression,
                      const Sequence<std::string,Allocator>& var_list,
                      const bool override = false)
      {
         const typename std::map<std::string,expression_t>::iterator itr = expr_map_.find(name);
 
         if (expr_map_.end() != itr)
         {
            if (!override)
            {
               exprtk_debug(("Compositor error(add): function '%s' already defined\n",
                             name.c_str()));
 
               return false;
            }
 
            remove(name, var_list.size());
         }
 
         if (compile_expression(name, expression, var_list))
         {
            const std::size_t n = var_list.size();
 
            fp_map_[n][name]->setup(expr_map_[name]);
 
            return true;
         }
         else
         {
            exprtk_debug(("Compositor error(add): Failed to compile function '%s'\n",
                          name.c_str()));
 
            return false;
         }
      }
 
   public:
 
      function_compositor()
      : parser_(settings_t::default_compile_all_opts +
                settings_t::e_disable_zero_return)
      , fp_map_(7)
      , load_variables_(false)
      , load_vectors_(false)
      {}
 
      explicit function_compositor(const symbol_table_t& st)
      : symbol_table_(st)
      , parser_(settings_t::default_compile_all_opts +
                settings_t::e_disable_zero_return)
      , fp_map_(7)
      , load_variables_(false)
      , load_vectors_(false)
      {}
 
     ~function_compositor()
      {
         clear();
      }
 
      inline symbol_table_t& symbol_table()
      {
         return symbol_table_;
      }
 
      inline const symbol_table_t& symbol_table() const
      {
         return symbol_table_;
      }
 
      inline void add_auxiliary_symtab(symbol_table_t& symtab)
      {
         auxiliary_symtab_list_.push_back(&symtab);
      }
 
      void load_variables(const bool load)
      {
         load_variables_ = load;
      }
 
      void load_vectors(const bool load)
      {
         load_vectors_ = load;
      }
 
      void clear()
      {
         symbol_table_.clear();
         expr_map_    .clear();
 
         for (std::size_t i = 0; i < fp_map_.size(); ++i)
         {
            typename funcparam_t::iterator itr = fp_map_[i].begin();
            typename funcparam_t::iterator end = fp_map_[i].end  ();
 
            while (itr != end)
            {
               delete itr->second;
               ++itr;
            }
 
            fp_map_[i].clear();
         }
      }
 
      inline bool add(const function& f, const bool override = false)
      {
         return add(f.name_, f.expression_, f.v_,override);
      }
 
      inline std::string error() const
      {
         if (!error_list_.empty())
         {
            return error_list_[0].diagnostic;
         }
         else
            return std::string("No Error");
      }
 
      inline std::size_t error_count() const
      {
         return error_list_.size();
      }
 
      inline parser_error::type get_error(const std::size_t& index) const
      {
         if (index < error_list_.size())
            return error_list_[index];
         else
            throw std::invalid_argument("compositor::get_error() - Invalid error index specified");
      }
 
   private:
 
      template <typename Allocator,
                template <typename, typename> class Sequence>
      bool compile_expression(const std::string& name,
                              const std::string& expression,
                              const Sequence<std::string,Allocator>& input_var_list,
                              bool  return_present = false)
      {
         expression_t compiled_expression;
         symbol_table_t local_symbol_table;
 
         local_symbol_table.load_from(symbol_table_);
         local_symbol_table.add_constants();
 
         if (load_variables_)
         {
            local_symbol_table.load_variables_from(symbol_table_);
         }
 
         if (load_vectors_)
         {
            local_symbol_table.load_vectors_from(symbol_table_);
         }
 
         error_list_.clear();
 
         if (!valid(name,input_var_list.size()))
         {
            parser_error::type error =
               parser_error::make_error(
                  parser_error::e_parser,
                  lexer::token(),
                  "ERR247 - Function '" + name + "' is an invalid overload",
                  exprtk_error_location);
 
            error_list_.push_back(error);
            return false;
         }
 
         if (!forward(name,
                      input_var_list.size(),
                      local_symbol_table,
                      return_present))
            return false;
 
         compiled_expression.register_symbol_table(local_symbol_table);
 
         for (std::size_t i = 0; i < auxiliary_symtab_list_.size(); ++i)
         {
            compiled_expression.register_symbol_table((*auxiliary_symtab_list_[i]));
         }
 
         std::string mod_expression;
 
         for (std::size_t i = 0; i < input_var_list.size(); ++i)
         {
            mod_expression += " var " + input_var_list[i] + "{};\n";
         }
 
         if (
              ('{' == details::front(expression)) &&
              ('}' == details::back (expression))
            )
            mod_expression += "~" + expression + ";";
         else
            mod_expression += "~{" + expression + "};";
 
         if (!parser_.compile(mod_expression,compiled_expression))
         {
            exprtk_debug(("Compositor Error: %s\n",parser_.error().c_str()));
            exprtk_debug(("Compositor modified expression: \n%s\n",mod_expression.c_str()));
 
            remove(name,input_var_list.size());
 
            for (std::size_t err_index = 0; err_index < parser_.error_count(); ++err_index)
            {
               error_list_.push_back(parser_.get_error(err_index));
            }
 
            return false;
         }
 
         if (!return_present && parser_.dec().return_present())
         {
            remove(name,input_var_list.size());
            return compile_expression(name, expression, input_var_list, true);
         }
 
         // Make sure every return point has a scalar as its first parameter
         if (parser_.dec().return_present())
         {
            typedef std::vector<std::string> str_list_t;
 
            str_list_t ret_param_list = parser_.dec().return_param_type_list();
 
            for (std::size_t i = 0; i < ret_param_list.size(); ++i)
            {
               const std::string& params = ret_param_list[i];
 
               if (params.empty() || ('T' != params[0]))
               {
                  exprtk_debug(("Compositor Error: Return statement in function '%s' is invalid\n",
                                name.c_str()));
 
                  remove(name,input_var_list.size());
 
                  return false;
               }
            }
         }
 
         expr_map_[name] = compiled_expression;
 
         exprtk::ifunction<T>& ifunc = (*(fp_map_[input_var_list.size()])[name]);
 
         if (symbol_table_.add_function(name,ifunc))
            return true;
         else
         {
            exprtk_debug(("Compositor Error: Failed to add function '%s' to symbol table\n",
                          name.c_str()));
            return false;
         }
      }
 
      inline bool symbol_used(const std::string& symbol) const
      {
         return (
                  symbol_table_.is_variable       (symbol) ||
                  symbol_table_.is_stringvar      (symbol) ||
                  symbol_table_.is_function       (symbol) ||
                  symbol_table_.is_vector         (symbol) ||
                  symbol_table_.is_vararg_function(symbol)
                );
      }
 
      inline bool valid(const std::string& name,
                        const std::size_t& arg_count) const
      {
         if (arg_count > 6)
            return false;
         else if (symbol_used(name))
            return false;
         else if (fp_map_[arg_count].end() != fp_map_[arg_count].find(name))
            return false;
         else
            return true;
      }
 
      inline bool forward(const std::string& name,
                          const std::size_t& arg_count,
                          symbol_table_t& sym_table,
                          const bool ret_present = false)
      {
         switch (arg_count)
         {
            #define case_stmt(N)                                     \
            case N : (fp_map_[arg_count])[name] =                    \
                     (!ret_present) ? static_cast<base_func*>        \
                                      (new func_##N##param) :        \
                                      static_cast<base_func*>        \
                                      (new func_##N##param_retval) ; \
                     break;                                          \
 
            case_stmt(0) case_stmt(1) case_stmt(2)
            case_stmt(3) case_stmt(4) case_stmt(5)
            case_stmt(6)
            #undef case_stmt
         }
 
         exprtk::ifunction<T>& ifunc = (*(fp_map_[arg_count])[name]);
 
         return sym_table.add_function(name,ifunc);
      }
 
      inline void remove(const std::string& name, const std::size_t& arg_count)
      {
         if (arg_count > 6)
            return;
 
         const typename std::map<std::string,expression_t>::iterator em_itr = expr_map_.find(name);
 
         if (expr_map_.end() != em_itr)
         {
            expr_map_.erase(em_itr);
         }
 
         const typename funcparam_t::iterator fp_itr = fp_map_[arg_count].find(name);
 
         if (fp_map_[arg_count].end() != fp_itr)
         {
            delete fp_itr->second;
            fp_map_[arg_count].erase(fp_itr);
         }
 
         symbol_table_.remove_function(name);
      }
 
   private:
 
      symbol_table_t symbol_table_;
      parser_t parser_;
      std::map<std::string,expression_t> expr_map_;
      std::vector<funcparam_t> fp_map_;
      std::vector<symbol_table_t*> auxiliary_symtab_list_;
      std::deque<parser_error::type> error_list_;
      bool load_variables_;
      bool load_vectors_;
   }; // class function_compositor
 
} // namespace exprtk
 
#if defined(_MSC_VER) || defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
#   ifndef NOMINMAX
#      define NOMINMAX
#   endif
#   ifndef WIN32_LEAN_AND_MEAN
#      define WIN32_LEAN_AND_MEAN
#   endif
#   include <windows.h>
#   include <ctime>
#else
#   include <ctime>
#   include <sys/time.h>
#   include <sys/types.h>
#endif
 
namespace exprtk
{
   class timer
   {
   public:
 
      #if defined(_MSC_VER) || defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
      timer()
      : in_use_(false)
      , start_time_{ 0 }
      , stop_time_ { 0 }
      {
         QueryPerformanceFrequency(&clock_frequency_);
      }
 
      inline void start()
      {
         in_use_ = true;
         QueryPerformanceCounter(&start_time_);
      }
 
      inline void stop()
      {
         QueryPerformanceCounter(&stop_time_);
         in_use_ = false;
      }
 
      inline double time() const
      {
         return (1.0 * (stop_time_.QuadPart - start_time_.QuadPart)) / (1.0 * clock_frequency_.QuadPart);
      }
 
      #else
 
      timer()
      : in_use_(false)
      {
         start_time_.tv_sec  = 0;
         start_time_.tv_usec = 0;
 
         stop_time_.tv_sec   = 0;
         stop_time_.tv_usec  = 0;
      }
 
      inline void start()
      {
         in_use_ = true;
         gettimeofday(&start_time_,0);
      }
 
      inline void stop()
      {
         gettimeofday(&stop_time_, 0);
         in_use_ = false;
      }
 
      inline unsigned long long int usec_time() const
      {
         if (!in_use_)
         {
            if (stop_time_.tv_sec >= start_time_.tv_sec)
            {
               return 1000000LLU * static_cast<details::_uint64_t>(stop_time_.tv_sec  - start_time_.tv_sec ) +
                                   static_cast<details::_uint64_t>(stop_time_.tv_usec - start_time_.tv_usec) ;
            }
            else
               return std::numeric_limits<details::_uint64_t>::max();
         }
         else
            return std::numeric_limits<details::_uint64_t>::max();
      }
 
      inline double time() const
      {
         return usec_time() * 0.000001;
      }
 
      #endif
 
      inline bool in_use() const
      {
         return in_use_;
      }
 
   private:
 
      bool in_use_;
 
      #if defined(_MSC_VER) || defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
         LARGE_INTEGER start_time_;
         LARGE_INTEGER stop_time_;
         LARGE_INTEGER clock_frequency_;
      #else
         struct timeval start_time_;
         struct timeval stop_time_;
      #endif
   };
 
   template <typename T>
   struct type_defs
   {
      typedef symbol_table<T>         symbol_table_t;
      typedef expression<T>           expression_t;
      typedef parser<T>               parser_t;
      typedef parser_error::type      error_t;
      typedef function_compositor<T>  compositor_t;
      typedef typename compositor_t::function function_t;
   };
 
} // namespace exprtk
 
#ifndef exprtk_disable_rtl_io
namespace exprtk
{
   namespace rtl { namespace io { namespace details
   {
      template <typename T>
      inline void print_type(const std::string& fmt,
                             const T v,
                             exprtk::details::numeric::details::real_type_tag)
      {
         #if defined(__clang__)
            #pragma clang diagnostic push
            #pragma clang diagnostic ignored "-Wformat-nonliteral"
         #elif defined(__GNUC__) || defined(__GNUG__)
            #pragma GCC diagnostic push
            #pragma GCC diagnostic ignored "-Wformat-nonliteral"
         #elif defined(_MSC_VER)
         #endif
 
         printf(fmt.c_str(), v);
 
         #if defined(__clang__)
            #pragma clang diagnostic pop
         #elif defined(__GNUC__) || defined(__GNUG__)
            #pragma GCC diagnostic pop
         #elif defined(_MSC_VER)
         #endif
      }
 
      template <typename T>
      struct print_impl
      {
         typedef typename igeneric_function<T>::generic_type generic_type;
         typedef typename igeneric_function<T>::parameter_list_t parameter_list_t;
         typedef typename generic_type::scalar_view scalar_t;
         typedef typename generic_type::vector_view vector_t;
         typedef typename generic_type::string_view string_t;
         typedef typename exprtk::details::numeric::details::number_type<T>::type num_type;
 
         static void process(const std::string& scalar_format, parameter_list_t parameters)
         {
            for (std::size_t i = 0; i < parameters.size(); ++i)
            {
               generic_type& gt = parameters[i];
 
               switch (gt.type)
               {
                  case generic_type::e_scalar : print(scalar_format,scalar_t(gt));
                                                break;
 
                  case generic_type::e_vector : print(scalar_format,vector_t(gt));
                                                break;
 
                  case generic_type::e_string : print(string_t(gt));
                                                break;
 
                  default                     : continue;
               }
            }
         }
 
         static inline void print(const std::string& scalar_format, const scalar_t& s)
         {
            print_type(scalar_format,s(),num_type());
         }
 
         static inline void print(const std::string& scalar_format, const vector_t& v)
         {
            for (std::size_t i = 0; i < v.size(); ++i)
            {
               print_type(scalar_format,v[i],num_type());
 
               if ((i + 1) < v.size())
                  printf(" ");
            }
         }
 
         static inline void print(const string_t& s)
         {
            printf("%s",to_str(s).c_str());
         }
      };
 
   } // namespace exprtk::rtl::io::details
 
   template <typename T>
   struct print exprtk_final : public exprtk::igeneric_function<T>
   {
      typedef typename igeneric_function<T>::parameter_list_t parameter_list_t;
 
      using exprtk::igeneric_function<T>::operator();
 
      explicit print(const std::string& scalar_format = "%10.5f")
      : scalar_format_(scalar_format)
      {
         exprtk::enable_zero_parameters(*this);
      }
 
      inline T operator() (parameter_list_t parameters) exprtk_override
      {
         details::print_impl<T>::process(scalar_format_,parameters);
         return T(0);
      }
 
      std::string scalar_format_;
   };
 
   template <typename T>
   struct println exprtk_final : public exprtk::igeneric_function<T>
   {
      typedef typename igeneric_function<T>::parameter_list_t parameter_list_t;
 
      using exprtk::igeneric_function<T>::operator();
 
      explicit println(const std::string& scalar_format = "%10.5f")
      : scalar_format_(scalar_format)
      {
         exprtk::enable_zero_parameters(*this);
      }
 
      inline T operator() (parameter_list_t parameters) exprtk_override
      {
         details::print_impl<T>::process(scalar_format_,parameters);
         printf("\n");
         return T(0);
      }
 
      std::string scalar_format_;
   };
 
   template <typename T>
   struct package
   {
      print  <T> p;
      println<T> pl;
 
      bool register_package(exprtk::symbol_table<T>& symtab)
      {
         #define exprtk_register_function(FunctionName, FunctionType)             \
         if (!symtab.add_function(FunctionName,FunctionType))                     \
         {                                                                        \
            exprtk_debug((                                                        \
              "exprtk::rtl::io::register_package - Failed to add function: %s\n", \
              FunctionName));                                                     \
            return false;                                                         \
         }                                                                        \
 
         exprtk_register_function("print"  , p )
         exprtk_register_function("println", pl)
         #undef exprtk_register_function
 
         return true;
      }
   };
 
   } // namespace exprtk::rtl::io
   } // namespace exprtk::rtl
}    // namespace exprtk
#endif
 
#ifndef exprtk_disable_rtl_io_file
#include <fstream>
namespace exprtk
{
   namespace rtl { namespace io { namespace file { namespace details
   {
      using ::exprtk::details::char_ptr;
      using ::exprtk::details::char_cptr;
 
      enum file_mode
      {
         e_error = 0,
         e_read  = 1,
         e_write = 2,
         e_rdwrt = 4
      };
 
      struct file_descriptor
      {
         file_descriptor(const std::string& fname, const std::string& access)
         : stream_ptr(0)
         , mode(get_file_mode(access))
         , file_name(fname)
         {}
 
         void*       stream_ptr;
         file_mode   mode;
         std::string file_name;
 
         bool open()
         {
            if (e_read == mode)
            {
               std::ifstream* stream = new std::ifstream(file_name.c_str(),std::ios::binary);
 
               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;
 
                  return false;
               }
 
               stream_ptr = stream;
 
               return true;
            }
            else if (e_write == mode)
            {
               std::ofstream* stream = new std::ofstream(file_name.c_str(),std::ios::binary);
 
               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;
 
                  return false;
               }
 
               stream_ptr = stream;
 
               return true;
            }
            else if (e_rdwrt == mode)
            {
               std::fstream* stream = new std::fstream(file_name.c_str(),std::ios::binary);
 
               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;
 
                  return false;
               }
 
               stream_ptr = stream;
 
               return true;
            }
 
            return false;
         }
 
         template <typename Stream, typename Ptr>
         void close(Ptr& p)
         {
            Stream* stream = reinterpret_cast<Stream*>(p);
            stream->close();
            delete stream;
            p = reinterpret_cast<Ptr>(0);
         }
 
         bool close()
         {
            switch (mode)
            {
               case e_read  : close<std::ifstream>(stream_ptr);
                              break;
 
               case e_write : close<std::ofstream>(stream_ptr);
                              break;
 
               case e_rdwrt : close<std::fstream> (stream_ptr);
                              break;
 
               default      : return false;
            }
 
            return true;
         }
 
         template <typename View>
         bool write(const View& view, const std::size_t amount, const std::size_t offset = 0)
         {
            switch (mode)
            {
               case e_write : reinterpret_cast<std::ofstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset), amount * sizeof(typename View::value_t));
                              break;
 
               case e_rdwrt : reinterpret_cast<std::fstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset) , amount * sizeof(typename View::value_t));
                              break;
 
               default      : return false;
            }
 
            return true;
         }
 
         template <typename View>
         bool read(View& view, const std::size_t amount, const std::size_t offset = 0)
         {
            switch (mode)
            {
               case e_read  : reinterpret_cast<std::ifstream*>(stream_ptr)->
                                 read(reinterpret_cast<char_ptr>(view.begin() + offset), amount * sizeof(typename View::value_t));
                              break;
 
               case e_rdwrt : reinterpret_cast<std::fstream*>(stream_ptr)->
                                 read(reinterpret_cast<char_ptr>(view.begin() + offset) , amount * sizeof(typename View::value_t));
                              break;
 
               default      : return false;
            }
 
            return true;
         }
 
         bool getline(std::string& s)
         {
            switch (mode)
            {
               case e_read  : return (!!std::getline(*reinterpret_cast<std::ifstream*>(stream_ptr),s));
               case e_rdwrt : return (!!std::getline(*reinterpret_cast<std::fstream* >(stream_ptr),s));
               default      : return false;
            }
         }
 
         bool eof() const
         {
            switch (mode)
            {
               case e_read  : return reinterpret_cast<std::ifstream*>(stream_ptr)->eof();
               case e_write : return reinterpret_cast<std::ofstream*>(stream_ptr)->eof();
               case e_rdwrt : return reinterpret_cast<std::fstream* >(stream_ptr)->eof();
               default      : return true;
            }
         }
 
         file_mode get_file_mode(const std::string& access) const
         {
            if (access.empty() || access.size() > 2)
               return e_error;
 
            std::size_t w_cnt = 0;
            std::size_t r_cnt = 0;
 
            for (std::size_t i = 0; i < access.size(); ++i)
            {
               switch (std::tolower(access[i]))
               {
                  case 'r' : r_cnt++; break;
                  case 'w' : w_cnt++; break;
                  default  : return e_error;
               }
            }
 
            if ((0 == r_cnt) && (0 == w_cnt))
               return e_error;
            else if ((r_cnt > 1) || (w_cnt > 1))
               return e_error;
            else if ((1 == r_cnt) && (1 == w_cnt))
               return e_rdwrt;
            else if (1 == r_cnt)
               return e_read;
            else
               return e_write;
         }
      };
 
      template <typename T>
      file_descriptor* make_handle(T v)
      {
         const std::size_t fd_size    = sizeof(details::file_descriptor*);
         details::file_descriptor* fd = reinterpret_cast<file_descriptor*>(0);
 
         std::memcpy(reinterpret_cast<char_ptr >(&fd),
                     reinterpret_cast<char_cptr>(&v ),
                     fd_size);
         return fd;
      }
 
      template <typename T>
      void perform_check()
      {
         #ifdef _MSC_VER
         #pragma warning(push)
         #pragma warning(disable: 4127)
         #endif
         if (sizeof(T) < sizeof(void*))
         {
            throw std::runtime_error("exprtk::rtl::io::file - Error - pointer size larger than holder.");
         }
         #ifdef _MSC_VER
         #pragma warning(pop)
         #endif
         assert(sizeof(T) <= sizeof(void*));
      }
 
   } // namespace exprtk::rtl::io::file::details
 
   template <typename T>
   class open exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::string_view    string_t;
 
      using igfun_t::operator();
 
      open()
      : exprtk::igeneric_function<T>("S|SS")
      { details::perform_check<T>(); }
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const std::string file_name = to_str(string_t(parameters[0]));
 
         if (file_name.empty())
            return T(0);
 
         if ((1 == ps_index) && (0 == string_t(parameters[1]).size()))
         {
            return T(0);
         }
 
         const std::string access =
            (0 == ps_index) ? "r" : to_str(string_t(parameters[1]));
 
         details::file_descriptor* fd = new details::file_descriptor(file_name,access);
 
         if (fd->open())
         {
            T t = T(0);
 
            const std::size_t fd_size = sizeof(details::file_descriptor*);
 
            std::memcpy(reinterpret_cast<char*>(&t ),
                        reinterpret_cast<char*>(&fd),
                        fd_size);
            return t;
         }
         else
         {
            delete fd;
            return T(0);
         }
      }
   };
 
   template <typename T>
   struct close exprtk_final : public exprtk::ifunction<T>
   {
      using exprtk::ifunction<T>::operator();
 
      close()
      : exprtk::ifunction<T>(1)
      { details::perform_check<T>(); }
 
      inline T operator() (const T& v) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(v);
 
         if (!fd->close())
            return T(0);
 
         delete fd;
 
         return T(1);
      }
   };
 
   template <typename T>
   class write exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::string_view    string_t;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      write()
      : igfun_t("TS|TST|TV|TVT")
      { details::perform_check<T>(); }
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());
 
         switch (ps_index)
         {
            case 0  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }
 
            case 1  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }
 
            case 2  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }
 
            case 3  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }
         }
 
         return T(0);
      }
   };
 
   template <typename T>
   class read exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::string_view    string_t;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      read()
      : igfun_t("TS|TST|TV|TVT")
      { details::perform_check<T>(); }
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());
 
         switch (ps_index)
         {
            case 0  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }
 
            case 1  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }
 
            case 2  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }
 
            case 3  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }
         }
 
         return T(0);
      }
   };
 
   template <typename T>
   class getline exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::string_view    string_t;
      typedef typename generic_type::scalar_view    scalar_t;
 
      using igfun_t::operator();
 
      getline()
      : igfun_t("T",igfun_t::e_rtrn_string)
      { details::perform_check<T>(); }
 
      inline T operator() (std::string& result, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());
         return T(fd->getline(result) ? 1 : 0);
      }
   };
 
   template <typename T>
   struct eof exprtk_final : public exprtk::ifunction<T>
   {
      using exprtk::ifunction<T>::operator();
 
      eof()
      : exprtk::ifunction<T>(1)
      { details::perform_check<T>(); }
 
      inline T operator() (const T& v) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(v);
 
         return (fd->eof() ? T(1) : T(0));
      }
   };
 
   template <typename T>
   struct package
   {
      open   <T> o;
      close  <T> c;
      write  <T> w;
      read   <T> r;
      getline<T> g;
      eof    <T> e;
 
      bool register_package(exprtk::symbol_table<T>& symtab)
      {
         #define exprtk_register_function(FunctionName, FunctionType)                   \
         if (!symtab.add_function(FunctionName,FunctionType))                           \
         {                                                                              \
            exprtk_debug((                                                              \
              "exprtk::rtl::io::file::register_package - Failed to add function: %s\n", \
              FunctionName));                                                           \
            return false;                                                               \
         }                                                                              \
 
         exprtk_register_function("open"    , o)
         exprtk_register_function("close"   , c)
         exprtk_register_function("write"   , w)
         exprtk_register_function("read"    , r)
         exprtk_register_function("getline" , g)
         exprtk_register_function("eof"     , e)
         #undef exprtk_register_function
 
         return true;
      }
   };
 
   } // namespace exprtk::rtl::io::file
   } // namespace exprtk::rtl::io
   } // namespace exprtk::rtl
}    // namespace exprtk
#endif
 
#ifndef exprtk_disable_rtl_vecops
namespace exprtk
{
   namespace rtl { namespace vecops {
 
   namespace helper
   {
      template <typename Vector>
      inline bool invalid_range(const Vector& v, const std::size_t r0, const std::size_t r1)
      {
         if (r0 > (v.size() - 1))
            return true;
         else if (r1 > (v.size() - 1))
            return true;
         else if (r1 < r0)
            return true;
         else
            return false;
      }
 
      template <typename T>
      struct load_vector_range
      {
         typedef typename exprtk::igeneric_function<T> igfun_t;
         typedef typename igfun_t::parameter_list_t    parameter_list_t;
         typedef typename igfun_t::generic_type        generic_type;
         typedef typename generic_type::scalar_view    scalar_t;
         typedef typename generic_type::vector_view    vector_t;
 
         static inline bool process(parameter_list_t& parameters,
                                    std::size_t& r0, std::size_t& r1,
                                    const std::size_t& r0_prmidx,
                                    const std::size_t& r1_prmidx,
                                    const std::size_t vec_idx = 0)
         {
            if (r0_prmidx >= parameters.size())
               return false;
 
            if (r1_prmidx >= parameters.size())
               return false;
 
            if (!scalar_t(parameters[r0_prmidx]).to_uint(r0))
               return false;
 
            if (!scalar_t(parameters[r1_prmidx]).to_uint(r1))
               return false;
 
            return !invalid_range(vector_t(parameters[vec_idx]), r0, r1);
         }
      };
   }
 
   namespace details
   {
      template <typename T>
      inline void kahan_sum(T& sum, T& error, const T v)
      {
         const T x = v - error;
         const T y = sum + x;
         error = (y - sum) - x;
         sum = y;
      }
 
   } // namespace exprtk::rtl::details
 
   template <typename T>
   class all_true exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      all_true()
      : exprtk::igeneric_function<T>("V|VTT")
        /*
           Overloads:
           0. V   - vector
           1. VTT - vector, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] == T(0))
            {
               return T(0);
            }
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class all_false exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      all_false()
      : exprtk::igeneric_function<T>("V|VTT")
        /*
           Overloads:
           0. V   - vector
           1. VTT - vector, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] != T(0))
            {
               return T(0);
            }
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class any_true exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      any_true()
      : exprtk::igeneric_function<T>("V|VTT")
        /*
           Overloads:
           0. V   - vector
           1. VTT - vector, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] != T(0))
            {
               return T(1);
            }
         }
 
         return T(0);
      }
   };
 
   template <typename T>
   class any_false exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      any_false()
      : exprtk::igeneric_function<T>("V|VTT")
        /*
           Overloads:
           0. V   - vector
           1. VTT - vector, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] == T(0))
            {
               return T(1);
            }
         }
 
         return T(0);
      }
   };
 
   template <typename T>
   class count exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      count()
      : exprtk::igeneric_function<T>("V|VTT")
        /*
           Overloads:
           0. V   - vector
           1. VTT - vector, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         std::size_t cnt = 0;
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] != T(0)) ++cnt;
         }
 
         return T(cnt);
      }
   };
 
   template <typename T>
   class copy exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      copy()
      : exprtk::igeneric_function<T>("VV|VTTVTT")
        /*
           Overloads:
           0. VV     - x(vector), y(vector)
           1. VTTVTT - x(vector), xr0, xr1, y(vector), yr0, yr1,
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
               vector_t y(parameters[(0 == ps_index) ? 1 : 3]);
 
         std::size_t xr0 = 0;
         std::size_t xr1 = x.size() - 1;
 
         std::size_t yr0 = 0;
         std::size_t yr1 = y.size() - 1;
 
         if (1 == ps_index)
         {
            if (
                 !helper::load_vector_range<T>::process(parameters, xr0, xr1, 1, 2, 0) ||
                 !helper::load_vector_range<T>::process(parameters, yr0, yr1, 4, 5, 3)
               )
               return T(0);
         }
 
         const std::size_t n = std::min(xr1 - xr0 + 1, yr1 - yr0 + 1);
 
         std::copy(
            x.begin() + xr0,
            x.begin() + xr0 + n,
            y.begin() + yr0);
 
         return T(n);
      }
   };
 
   template <typename T>
   class rol exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      rol()
      : exprtk::igeneric_function<T>("VT|VTTT")
        /*
           Overloads:
           0. VT   - vector, N
           1. VTTT - vector, N, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         std::size_t n  = 0;
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)
            )
            return T(0);
 
         const std::size_t dist  = r1 - r0 + 1;
         const std::size_t shift = n % dist;
 
         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + shift,
            vec.begin() + r1 + 1);
 
         return T(1);
      }
   };
 
   template <typename T>
   class ror exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      ror()
      : exprtk::igeneric_function<T>("VT|VTTT")
        /*
           Overloads:
           0. VT   - vector, N
           1. VTTT - vector, N, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         std::size_t n  = 0;
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)
            )
            return T(0);
 
         const std::size_t dist  = r1 - r0 + 1;
         const std::size_t shift = (dist - (n % dist)) % dist;
 
         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + shift,
            vec.begin() + r1 + 1);
 
         return T(1);
      }
   };
 
   template <typename T>
   class shift_left exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      shift_left()
      : exprtk::igeneric_function<T>("VT|VTTT")
        /*
           Overloads:
           0. VT   - vector, N
           1. VTTT - vector, N, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         std::size_t n  = 0;
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)
            )
            return T(0);
 
         const std::size_t dist = r1 - r0 + 1;
 
         if (n > dist)
            return T(0);
 
         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + n,
            vec.begin() + r1 + 1);
 
         for (std::size_t i = r1 - n + 1; i <= r1; ++i)
         {
            vec[i] = T(0);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class shift_right exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      shift_right()
      : exprtk::igeneric_function<T>("VT|VTTT")
        /*
           Overloads:
           0. VT   - vector, N
           1. VTTT - vector, N, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         std::size_t n  = 0;
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)
            )
            return T(0);
 
         const std::size_t dist = r1 - r0 + 1;
 
         if (n > dist)
            return T(0);
 
         const std::size_t shift = (dist - (n % dist)) % dist;
 
         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + shift,
            vec.begin() + r1 + 1);
 
         for (std::size_t i = r0; i < r0 + n; ++i)
         {
            vec[i] = T(0);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class sort exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::string_view    string_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      sort()
      : exprtk::igeneric_function<T>("V|VTT|VS|VSTT")
        /*
           Overloads:
           0. V    - vector
           1. VTT  - vector, r0, r1
           2. VS   - vector, string
           3. VSTT - vector, string, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0))
            return T(0);
         if ((3 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0))
            return T(0);
 
         bool ascending = true;
 
         if ((2 == ps_index) || (3 == ps_index))
         {
            if (exprtk::details::imatch(to_str(string_t(parameters[1])),"ascending"))
               ascending = true;
            else if (exprtk::details::imatch(to_str(string_t(parameters[1])),"descending"))
               ascending = false;
            else
               return T(0);
         }
 
         if (ascending)
            std::sort(
               vec.begin() + r0,
               vec.begin() + r1 + 1,
               std::less<T>());
         else
            std::sort(
               vec.begin() + r0,
               vec.begin() + r1 + 1,
               std::greater<T>());
 
         return T(1);
      }
   };
 
   template <typename T>
   class nthelement exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      nthelement()
      : exprtk::igeneric_function<T>("VT|VTTT")
        /*
           Overloads:
           0. VT   - vector, nth-element
           1. VTTT - vector, nth-element, r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         std::size_t n  = 0;
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0))
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         std::nth_element(
            vec.begin() + r0,
            vec.begin() + r0 + n ,
            vec.begin() + r1 + 1);
 
         return T(1);
      }
   };
 
   template <typename T>
   class assign exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      assign()
      : exprtk::igeneric_function<T>("VT|VTTT|VTTTT")
        /*
           Overloads:
           0. VT    - vector, V
           1. VTTT  - vector, V, r0, r1
           2. VTTTT - vector, V, r0, r1, SS
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         const T assign_value = scalar_t(parameters[1]);
 
         const T step_size = (2 == ps_index) ?
                             scalar_t(parameters.back())() :
                             T(1) ;
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              ((ps_index == 1) || (ps_index == 2)) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)
            )
         {
            return T(0);
         }
 
         for (std::size_t i = r0; i <= r1; i += step_size)
         {
            vec[i] = assign_value;
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class iota exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      iota()
      : exprtk::igeneric_function<T>("VTT|VT|VTTTT|VTTT")
        /*
           Overloads:
           0. VTT  - vector, SV, SS
           1. VT   - vector, SV, SS (+1)
           2. VTTT - vector, r0, r1, SV, SS
           3. VTT  - vector, r0, r1, SV, SS (+1)
 
           Where:
           1. SV - Start value
           2. SS - Step size
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         const T start_value = (ps_index <= 1) ?
                               scalar_t(parameters[1]) :
                               scalar_t(parameters[3]) ;
 
         const T step_size = ((0 == ps_index) || (2 == ps_index)) ?
                             scalar_t(parameters.back())() :
                             T(1) ;
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              ((ps_index == 2) || (ps_index == 3)) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return T(0);
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            vec[i] = start_value + ((i - r0) * step_size);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class sumk exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      sumk()
      : exprtk::igeneric_function<T>("V|VTT|VTTT")
        /*
           Overloads:
           0. V    - vector
           1. VTT  - vector, r0, r1
           2. VTTT - vector, r0, r1, stride
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);
 
         const std::size_t stride = (2 != ps_index) ?
                                    1 :
                                    static_cast<std::size_t>(scalar_t(parameters[3]));
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              ((1 == ps_index) || (2 == ps_index)) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }
 
         T result = T(0);
         T error  = T(0);
 
         for (std::size_t i = r0; i <= r1;  i += stride)
         {
            details::kahan_sum(result, error, vec[i]);
         }
 
         return result;
      }
   };
 
   template <typename T>
   class axpy exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpy()
      : exprtk::igeneric_function<T>("TVV|TVVTT")
        /*
           y <- ax + y
           Overloads:
           0. TVV   - a, x(vector), y(vector)
           1. TVVTT - a, x(vector), y(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t y(parameters[2]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 3, 4, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            y[i] = (a * x[i]) + y[i];
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class axpby exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpby()
      : exprtk::igeneric_function<T>("TVTV|TVTVTT")
        /*
           y <- ax + by
           Overloads:
           0. TVTV   - a, x(vector), b, y(vector)
           1. TVTVTT - a, x(vector), b, y(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t y(parameters[3]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
         const T b = scalar_t(parameters[2])();
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            y[i] = (a * x[i]) + (b * y[i]);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class axpyz exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpyz()
      : exprtk::igeneric_function<T>("TVVV|TVVVTT")
        /*
           z <- ax + y
           Overloads:
           0. TVVV   - a, x(vector), y(vector), z(vector)
           1. TVVVTT - a, x(vector), y(vector), z(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
         const vector_t y(parameters[2]);
               vector_t z(parameters[3]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(z, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            z[i] = (a * x[i]) + y[i];
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class axpbyz exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpbyz()
      : exprtk::igeneric_function<T>("TVTVV|TVTVVTT")
        /*
           z <- ax + by
           Overloads:
           0. TVTVV   - a, x(vector), b, y(vector), z(vector)
           1. TVTVVTT - a, x(vector), b, y(vector), z(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
         const vector_t y(parameters[3]);
               vector_t z(parameters[4]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 5, 6, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(z, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
         const T b = scalar_t(parameters[2])();
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            z[i] = (a * x[i]) + (b * y[i]);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class axpbsy exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpbsy()
      : exprtk::igeneric_function<T>("TVTTV|TVTTVTT")
        /*
           y <- ax + by
           Overloads:
           0. TVTVV   - a, x(vector), b, shift, y(vector), z(vector)
           1. TVTVVTT - a, x(vector), b, shift, y(vector), z(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t y(parameters[4]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 5, 6, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
         const T b = scalar_t(parameters[2])();
 
         const std::size_t s = static_cast<std::size_t>(scalar_t(parameters[3])());
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            y[i] = (a * x[i]) + (b * y[i + s]);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class axpbsyz exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpbsyz()
      : exprtk::igeneric_function<T>("TVTTVV|TVTTVVTT")
        /*
           z <- ax + by
           Overloads:
           0. TVTVV   - a, x(vector), b, shift, y(vector), z(vector)
           1. TVTVVTT - a, x(vector), b, shift, y(vector), z(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
         const vector_t y(parameters[4]);
               vector_t z(parameters[5]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 6, 7, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(z, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
         const T b = scalar_t(parameters[2])();
 
         const std::size_t s = static_cast<std::size_t>(scalar_t(parameters[3])());
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            z[i] = (a * x[i]) + (b * y[i + s]);
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class axpbz exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      axpbz()
      : exprtk::igeneric_function<T>("TVTV|TVTVTT")
        /*
           z <- ax + b
           Overloads:
           0. TVTV   - a, x(vector), b, z(vector)
           1. TVTVTT - a, x(vector), b, z(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t z(parameters[3]);
 
         std::size_t r0 = 0;
         std::size_t r1 = x.size() - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(z, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         const T a = scalar_t(parameters[0])();
         const T b = scalar_t(parameters[2])();
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            z[i] = (a * x[i]) + b;
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class diff exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      diff()
      : exprtk::igeneric_function<T>("VV|VVT")
        /*
           x_(i - stride) - x_i
           Overloads:
           0. VV  - x(vector), y(vector)
           1. VVT - x(vector), y(vector), stride
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
               vector_t y(parameters[1]);
 
         const std::size_t r0 = 0;
         const std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         const std::size_t stride = (1 != ps_index) ? 1 :
                                    std::min(r1,static_cast<std::size_t>(scalar_t(parameters[2])));
 
         for (std::size_t i = 0; i < stride; ++i)
         {
            y[i] = std::numeric_limits<T>::quiet_NaN();
         }
 
         for (std::size_t i = (r0 + stride); i <= r1; ++i)
         {
            y[i] = x[i] - x[i - stride];
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class dot exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      dot()
      : exprtk::igeneric_function<T>("VV|VVTT")
        /*
           Overloads:
           0. VV   - x(vector), y(vector)
           1. VVTT - x(vector), y(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
         const vector_t y(parameters[1]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         T result = T(0);
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            result += (x[i] * y[i]);
         }
 
         return result;
      }
   };
 
   template <typename T>
   class dotk exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      dotk()
      : exprtk::igeneric_function<T>("VV|VVTT")
        /*
           Overloads:
           0. VV   - x(vector), y(vector)
           1. VVTT - x(vector), y(vector), r0, r1
        */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
         const vector_t y(parameters[1]);
 
         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;
 
         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
 
         T result = T(0);
         T error  = T(0);
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            details::kahan_sum(result, error, (x[i] * y[i]));
         }
 
         return result;
      }
   };
 
   template <typename T>
   class threshold_below exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      threshold_below()
      : exprtk::igeneric_function<T>("VTT|VTTTT")
      /*
         Overloads:
         0. VTT   - vector, TV, SV
         1. VTTTT - vector, r0, r1, TV, SV
 
         Where:
         TV - Threshold value
         SV - Snap-to value
      */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         const T threshold_value = (0 == ps_index) ?
                                   scalar_t(parameters[1]) :
                                   scalar_t(parameters[3]) ;
 
         const T snap_value = scalar_t(parameters.back());
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return T(0);
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] < threshold_value)
            {
               vec[i] = snap_value;
            }
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   class threshold_above exprtk_final : public exprtk::igeneric_function<T>
   {
   public:
 
      typedef typename exprtk::igeneric_function<T> igfun_t;
      typedef typename igfun_t::parameter_list_t    parameter_list_t;
      typedef typename igfun_t::generic_type        generic_type;
      typedef typename generic_type::scalar_view    scalar_t;
      typedef typename generic_type::vector_view    vector_t;
 
      using igfun_t::operator();
 
      threshold_above()
      : exprtk::igeneric_function<T>("VTT|VTTTT")
      /*
         Overloads:
         0. VTT   - vector, TV, SV
         1. VTTTT - vector, r0, r1, TV, SV
 
         Where:
         TV - Threshold value
         SV - Snap-to value
      */
      {}
 
      inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);
 
         const T threshold_value = (0 == ps_index) ?
                                   scalar_t(parameters[1]) :
                                   scalar_t(parameters[3]) ;
 
         const T snap_value = scalar_t(parameters.back());
 
         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;
 
         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return T(0);
         }
 
         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] > threshold_value)
            {
               vec[i] = snap_value;
            }
         }
 
         return T(1);
      }
   };
 
   template <typename T>
   struct package
   {
      all_true       <T> at;
      all_false      <T> af;
      any_true       <T> nt;
      any_false      <T> nf;
      count          <T>  c;
      copy           <T> cp;
      rol            <T> rl;
      ror            <T> rr;
      shift_left     <T> sl;
      shift_right    <T> sr;
      sort           <T> st;
      nthelement     <T> ne;
      assign         <T> an;
      iota           <T> ia;
      sumk           <T> sk;
      axpy           <T> b1_axpy;
      axpby          <T> b1_axpby;
      axpyz          <T> b1_axpyz;
      axpbyz         <T> b1_axpbyz;
      axpbsy         <T> b1_axpbsy;
      axpbsyz        <T> b1_axpbsyz;
      axpbz          <T> b1_axpbz;
      diff           <T> df;
      dot            <T> dt;
      dotk           <T> dtk;
      threshold_above<T> ta;
      threshold_below<T> tb;
 
      bool register_package(exprtk::symbol_table<T>& symtab)
      {
         #define exprtk_register_function(FunctionName, FunctionType)                 \
         if (!symtab.add_function(FunctionName,FunctionType))                         \
         {                                                                            \
            exprtk_debug((                                                            \
              "exprtk::rtl::vecops::register_package - Failed to add function: %s\n", \
              FunctionName));                                                         \
            return false;                                                             \
         }                                                                            \
 
         exprtk_register_function("all_true"        , at        )
         exprtk_register_function("all_false"       , af        )
         exprtk_register_function("any_true"        , nt        )
         exprtk_register_function("any_false"       , nf        )
         exprtk_register_function("count"           , c         )
         exprtk_register_function("copy"            , cp        )
         exprtk_register_function("rotate_left"     , rl        )
         exprtk_register_function("rol"             , rl        )
         exprtk_register_function("rotate_right"    , rr        )
         exprtk_register_function("ror"             , rr        )
         exprtk_register_function("shftl"           , sl        )
         exprtk_register_function("shftr"           , sr        )
         exprtk_register_function("sort"            , st        )
         exprtk_register_function("nth_element"     , ne        )
         exprtk_register_function("assign"          , an        )
         exprtk_register_function("iota"            , ia        )
         exprtk_register_function("sumk"            , sk        )
         exprtk_register_function("axpy"            , b1_axpy   )
         exprtk_register_function("axpby"           , b1_axpby  )
         exprtk_register_function("axpyz"           , b1_axpyz  )
         exprtk_register_function("axpbyz"          , b1_axpbyz )
         exprtk_register_function("axpbsy"          , b1_axpbsy )
         exprtk_register_function("axpbsyz"         , b1_axpbsyz)
         exprtk_register_function("axpbz"           , b1_axpbz  )
         exprtk_register_function("diff"            , df        )
         exprtk_register_function("dot"             , dt        )
         exprtk_register_function("dotk"            , dtk       )
         exprtk_register_function("threshold_above" , ta        )
         exprtk_register_function("threshold_below" , tb        )
         #undef exprtk_register_function
 
         return true;
      }
   };
 
   } // namespace exprtk::rtl::vecops
   } // namespace exprtk::rtl
}    // namespace exprtk
#endif
 
namespace exprtk
{
   namespace information
   {
      using ::exprtk::details::char_cptr;
 
      static char_cptr library = "Mathematical Expression Toolkit";
      static char_cptr version = "2.718281828459045235360287471352662"
                                 "49775724709369995957496696762772407"
                                 "66303535475945713821785251664274274"
                                 "66391932003059921817413596629043572";
      static char_cptr date    = "20240101";
      static char_cptr min_cpp = "199711L";
 
      static inline std::string data()
      {
         static const std::string info_str = std::string(library) +
                                             std::string(" v") + std::string(version) +
                                             std::string(" (") + date + std::string(")") +
                                             std::string(" (") + min_cpp + std::string(")");
         return info_str;
      }
 
   } // namespace information
 
   #ifdef exprtk_debug
   #undef exprtk_debug
   #endif
 
   #ifdef exprtk_error_location
   #undef exprtk_error_location
   #endif
 
   #ifdef exprtk_override
   #undef exprtk_override
   #endif
 
   #ifdef exprtk_final
   #undef exprtk_final
   #endif
 
   #ifdef exprtk_delete
   #undef exprtk_delete
   #endif
 
} // namespace exprtk
 
#endif

batch_eqineq_logic_case

#define batch_eqineq_logic_case

Value:

            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_equal , details::equal_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 ) \

case_stmt [1/60]

#define case_stmt

(

cp

)

Value:

               case cp : return node_allocator_->                                        \
                            allocate<IPowNode<T,details::numeric::fast_exp<T,cp> > >(v); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [2/60]

#define case_stmt

(

N

)

Value:

                  case N : { std::swap(s0[i], s1[i]); ++i; } \
                  exprtk_fallthrough                         \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [3/60]

#define case_stmt

(

N

)

Value:

               case N : *vec++ = v; \
               exprtk_fallthrough   \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [4/60]

#define case_stmt

(

N

)

Value:

               case N : { vec2[i] = Operation::process(vec0[i], vec1[i]); ++i; } \
               exprtk_fallthrough                                                \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [5/60]

#define case_stmt

(

N

)

Value:

               case N : { vec1[i] = Operation::process(vec0[i]); ++i; } \
               exprtk_fallthrough                                       \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [6/60]

#define case_stmt

(

N

)

if (is_true(arg[(2 * N)].first)) { return arg[(2 * N) + 1].first->value(); } \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [7/60]

#define case_stmt

(

N

)

Value:

               case N :                                                                   \
                  return node_allocator_->                                                \
                            allocate<details::switch_n_node                               \
                              <Type,typename switch_nodes::switch_impl_##N > >(arg_list); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [8/60]

#define case_stmt

(

N

)

Value:

            case N : (fp_map_[arg_count])[name] =                    \
                     (!ret_present) ? static_cast<base_func*>        \
                                      (new func_##N##param) :        \
                                      static_cast<base_func*>        \
                                      (new func_##N##param_retval) ; \
                     break;                                          \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [9/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : *vec0++ = *vec1++;       \
               fall_through                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [10/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : Operation::assign(*vec++,v); \
               fall_through                          \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [11/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : { vec0[i] = Operation::process(vec0[i], vec1[i]); ++i; } \
               fall_through                                                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [12/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : { vec1[i] = Operation::process(vec0[i], v); ++i; } \
               fall_through                                                \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [13/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : { vec0[i] = Operation::process(v, vec1[i]); ++i; } \
               fall_through                                                \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [14/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

                  case N : result += vec[i++];      \
                  fall_through                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [15/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : r[0] += vec[i++];        \
               fall_through                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [16/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

                  case N : result *= vec[i++];      \
                  fall_through                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [17/60]

#define case_stmt	(		N,
			fall_through
	)

Value:

               case N : r[0] *= vec[i++];        \
               fall_through                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [18/60]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : temp_node = node_allocator_->                       \
                             allocate<details::sf3_node<Type,details::sf##op##_op<Type> > > \
                                (operation, branch);                                        \
                             break;                                                         \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [19/60]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : return node_allocator_->                                    \
                             allocate_rrr<details::sf3_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2);                                                       \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [20/60]

#define case_stmt

(

op

)

Value:

                  case details::e_sf##op : return node_allocator_->                            \
                                allocate<details::sf3_node<Type,details::sf##op##_op<Type> > > \
                                   (operation, branch);                                        \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [21/60]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : temp_node = node_allocator_->                                   \
                                         allocate<details::sf4_node<Type,details::sf##op##_op<Type> > > \
                                            (operation, branch);                                        \
                                        break;                                                          \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [22/60]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : return node_allocator_->                                     \
                             allocate_rrrr<details::sf4_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2, v3);                                                    \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [23/60]

#define case_stmt

(

op

)

Value:

               case details::e_sf##op : return node_allocator_->                            \
                             allocate<details::sf4_node<Type,details::sf##op##_op<Type> > > \
                                (operation, branch);                                        \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [24/60]

#define case_stmt

(

op

)

Value:

                  case details::e_sf##op : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,details::sf##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2);                                   \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [25/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                 \
                             allocate<typename details::unary_variable_node<Type,op1<Type> > >(v); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [26/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                           \
                             allocate<typename details::unary_vector_node<Type,op1<Type> > > \
                                (operation, branch[0]);                                      \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [27/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                       \
                             allocate<typename details::unary_branch_node<Type,op1<Type> > >(branch[0]); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [28/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : temp_node = node_allocator_->                                   \
                                         allocate<details::vararg_node<Type,op1<Type> > > \
                                            (arg_list);                                   \
                          break;                                                          \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [29/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                          \
                             allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [30/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return node_allocator_->                                             \
                                allocate<details::vectorize_node<Type,op1<Type> > >(arg_list[0]); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [31/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                     \
                                allocate<details::vararg_node<Type,op1<Type> > >(arg_list); \
                             break;                                                         \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [32/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                       \
                                template allocate_rrr<typename details::assignment_op_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                         \
                             node_name = "assignment_op_node";                                                \
                             break;                                                                           \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [33/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                 \
                                 template allocate_rrr<typename details::assignment_vec_elem_op_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                  \
                             node_name = "assignment_vec_elem_op_node";                                                 \
                             break;                                                                                     \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [34/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                     \
                                 template allocate_rrr<typename details::assignment_vec_elem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                      \
                             node_name = "assignment_vec_elem_op_rtc_node";                                                 \
                             break;                                                                                         \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [35/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                      \
                                 template allocate_rrr<typename details::assignment_vec_celem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                       \
                             node_name = "assignment_vec_celem_op_rtc_node";                                                 \
                             break;                                                                                          \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [36/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                       \
                                 template allocate_rrr<typename details::assignment_rebasevec_elem_op_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                        \
                             node_name = "assignment_rebasevec_elem_op_node";                                                 \
                             break;                                                                                           \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [37/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                        \
                                 template allocate_rrr<typename details::assignment_rebasevec_celem_op_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                         \
                             node_name = "assignment_rebasevec_celem_op_node";                                                 \
                             break;                                                                                            \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [38/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                           \
                                 template allocate_rrr<typename details::assignment_rebasevec_elem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                            \
                             node_name = "assignment_rebasevec_elem_op_rtc_node";                                                 \
                             break;                                                                                               \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [39/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                                            \
                                 template allocate_rrr<typename details::assignment_rebasevec_celem_op_rtc_node<Type,op1<Type> > > \
                                    (operation, branch[0], branch[1]);                                                             \
                             node_name = "assignment_rebasevec_celem_op_rtc_node";                                                 \
                             break;                                                                                                \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [40/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                     case op0 : result = node_allocator_->                                                              \
                                   template allocate_rrr<typename details::assignment_vecvec_op_node<Type,op1<Type> > > \
                                      (operation, branch[0], branch[1]);                                                \
                                node_name = "assignment_rebasevec_celem_op_node";                                       \
                                break;                                                                                  \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [41/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                     case op0 : result = node_allocator_->                                                           \
                                   template allocate_rrr<typename details::assignment_vec_op_node<Type,op1<Type> > > \
                                      (operation, branch[0], branch[1]);                                             \
                                node_name = "assignment_vec_op_node";                                                \
                                break;                                                                               \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [42/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecvec_node";                                                \
                             break;                                                                              \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [43/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecval_node";                                                \
                             break;                                                                              \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [44/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_valvec_node";                                                \
                             break;                                                                              \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [45/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_vecvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecvec_node";                                                \
                             break;                                                                              \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [46/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_vecval_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecval_node(b0ivec,!b1ivec)";                                \
                             break;                                                                              \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [47/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : result = node_allocator_->                                                          \
                                template allocate_rrr<typename details::vec_binop_valvec_node<Type,op1<Type> > > \
                                   (operation, branch[0], branch[1]);                                            \
                             node_name = "vec_binop_vecval_node(!b0ivec,b1ivec)";                                \
                             break;                                                                              \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [48/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                         \
                                template allocate<typename details::binary_ext_node<Type,op1<Type> > > \
                                   (branch[0], branch[1]);                                             \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [49/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::vob_node<Type,op1<Type> > > \
                                   (v, branch[1]);                                                 \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [50/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::bov_node<Type,op1<Type> > > \
                                   (branch[0], v);                                                 \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [51/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_tt<typename details::cob_node<Type,op1<Type> > > \
                                   (c,  branch[1]);                                                \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [52/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::boc_node<Type,op1<Type> > > \
                                   (branch[0], c);                                                 \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [53/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rr<typename details::vov_node<Type,op1<Type> > > \
                                   (v1, v2);                                                       \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [54/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_cr<typename details::cov_node<Type,op1<Type> > > \
                                   (c, v);                                                         \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [55/60]

#define case_stmt	(		op0,
			op1
	)

Value:

                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rc<typename details::voc_node<Type,op1<Type> > > \
                                   (v, c);                                                         \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [56/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                              \
                             allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp0);                                                                  \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [57/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                              \
                             allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp1);                                                                  \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [58/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                                \
                             allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \
                                (s0, s1, rp0, rp1);                                                               \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [59/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                                         \
                             allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0, s1); \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt [60/60]

#define case_stmt	(		op0,
			op1
	)

Value:

               case op0 : return node_allocator_->                                              \
                             allocate_ttt<typename details::str_sogens_node<Type,op1<Type> > >  \
                                (opr, branch[0], branch[1]);                                    \

Definition at line 31297 of file exprtk.hpp.

                                             { return arg[(2 * N) + 1].first->value(); } \
 

case_stmt0

#define case_stmt0

(

op

)

Value:

                  case details::e_sf##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sf##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3);                                        \

case_stmt1

#define case_stmt1

(

op

)

Value:

                  case details::e_sf4ext##op : return details::T0oT1oT2oT3_sf4ext<Type,T0,T1,T2,T3,details::sfext##op##_op<Type> >:: \
                                allocate(*(expr_gen.node_allocator_), t0, t1, t2, t3);                                               \

def_fp_retval

#define def_fp_retval

(

N

)

Value:

      struct func_##N##param_retval exprtk_final : public func_##N##param \
      {                                                                   \
         inline T value(expression_t& e) exprtk_override                  \
         {                                                                \
            return return_value(e);                                       \
         }                                                                \
      };                                                                  \

Definition at line 41459 of file exprtk.hpp.

                                                 : public func_##N##param \
      {                                                                   \
         inline T value(expression_t& e) exprtk_override                  \
         {                                                                \
            return return_value(e);                                       \
         }                                                                \
      };                                                                  \
 

define_sfop3

#define define_sfop3	(		NN,
			OP0,
			OP1
	)

Value:

      template <typename T>                              \
      struct sf##NN##_op : public sf_base<T>             \
      {                                                  \
         typedef typename sf_base<T>::Type const Type;   \
         static inline T process(Type x, Type y, Type z) \
         {                                               \
            return (OP0);                                \
         }                                               \
         static inline std::string id()                  \
         {                                               \
            return (OP1);                                \
         }                                               \
      };                                                 \

Definition at line 11120 of file exprtk.hpp.

                         : public sf_base<T>             \
      {                                                  \
         typedef typename sf_base<T>::Type const Type;   \
         static inline T process(Type x, Type y, Type z) \
         {                                               \
            return (OP0);                                \
         }                                               \
         static inline std::string id()                  \
         {                                               \
            return (OP1);                                \
         }                                               \
      };                                                 \
 

define_sfop4

#define define_sfop4	(		NN,
			OP0,
			OP1
	)

Value:

      template <typename T>                                      \
      struct sf##NN##_op : public sf_base<T>                     \
      {                                                          \
         typedef typename sf_base<T>::Type const Type;           \
         static inline T process(Type x, Type y, Type z, Type w) \
         {                                                       \
            return (OP0);                                        \
         }                                                       \
         static inline std::string id()                          \
         {                                                       \
            return (OP1);                                        \
         }                                                       \
      };                                                         \

Definition at line 11184 of file exprtk.hpp.

                         : public sf_base<T>                     \
      {                                                          \
         typedef typename sf_base<T>::Type const Type;           \
         static inline T process(Type x, Type y, Type z, Type w) \
         {                                                       \
            return (OP0);                                        \
         }                                                       \
         static inline std::string id()                          \
         {                                                       \
            return (OP1);                                        \
         }                                                       \
      };                                                         \
 

empty_method_body

#define empty_method_body

(

N

)

Value:

      {                                              \
         exprtk_debug(("ifunction::operator() - Operator(" #N ") has not been overridden\n")); \
         return std::numeric_limits<T>::quiet_NaN(); \
      }                                              \

Definition at line 18870 of file exprtk.hpp.

      {                                              \
         exprtk_debug(("ifunction::operator() - Operator(" #N ") has not been overridden\n")); \
         return std::numeric_limits<T>::quiet_NaN(); \
      }                                              \
 

exprtk_assign

#define exprtk_assign

(

Index

)

(*v[Index]) = v##Index; \

Definition at line 41119 of file exprtk.hpp.

exprtk_crtype

#define exprtk_crtype

(

Type

)

param_to_str<is_const_ref< Type >::result>::result() \

Definition at line 16315 of file exprtk.hpp.

exprtk_debug

#define exprtk_debug

(

params

)

(void)0

Definition at line 64 of file exprtk.hpp.

exprtk_define_epsilon_type

#define exprtk_define_epsilon_type	(		Type,
			Epsilon
	)

Value:

            template <> struct epsilon_type<Type>                  \
            {                                                      \
               static inline Type value()                          \
               {                                                   \
                  const Type epsilon = static_cast<Type>(Epsilon); \
                  return epsilon;                                  \
               }                                                   \
            };                                                     \

Definition at line 855 of file exprtk.hpp.

            {                                                      \
               static inline Type value()                          \
               {                                                   \
                  const Type epsilon = static_cast<Type>(Epsilon); \
                  return epsilon;                                  \
               }                                                   \
            };                                                     \
 

exprtk_define_erf

#define exprtk_define_erf	(		TT,
			impl
	)		inline TT erf_impl(const TT v) { return impl(v); } \

Definition at line 1237 of file exprtk.hpp.

                                           { return impl(v); } \
 

exprtk_define_erfc

#define exprtk_define_erfc	(		TT,
			impl
	)		inline TT erfc_impl(const TT v) { return impl(v); } \

Definition at line 1282 of file exprtk.hpp.

                                            { return impl(v); } \
 

exprtk_define_freefunction

#define exprtk_define_freefunction

(

NN

)

Value:

      inline bool add_function(const std::string& function_name, ff##NN##_functor function) \
      {                                                                                     \
         if (!valid())                                                                      \
         { return false; }                                                                  \
         if (!valid_symbol(function_name))                                                  \
         { return false; }                                                                  \
         if (symbol_exists(function_name))                                                  \
         { return false; }                                                                  \
                                                                                            \
         exprtk::ifunction<T>* ifunc = new freefunc##NN(function);                          \
                                                                                            \
         local_data().free_function_list_.push_back(ifunc);                                 \
                                                                                            \
         return add_function(function_name,(*local_data().free_function_list_.back()));     \
      }                                                                                     \

Definition at line 20180 of file exprtk.hpp.

      {                                                                                     \
         if (!valid())                                                                      \
         { return false; }                                                                  \
         if (!valid_symbol(function_name))                                                  \
         { return false; }                                                                  \
         if (symbol_exists(function_name))                                                  \
         { return false; }                                                                  \
                                                                                            \
         exprtk::ifunction<T>* ifunc = new freefunc##NN(function);                          \
                                                                                            \
         local_data().free_function_list_.push_back(ifunc);                                 \
                                                                                            \
         return add_function(function_name,(*local_data().free_function_list_.back()));     \
      }                                                                                     \
 

exprtk_define_process

#define exprtk_define_process

(

Type

)

Value:

            static inline void process(std::pair<bool,Type*>& n) \
            {                                                    \
               delete n.second;                                  \
            }                                                    \

Definition at line 19294 of file exprtk.hpp.

            {                                                    \
               delete n.second;                                  \
            }                                                    \
 

exprtk_define_unary_function

#define exprtk_define_unary_function

(

FunctionName

)

Value:

         template <typename T>                                     \
         inline T FunctionName (const T v)                         \
         {                                                         \
            const typename details::number_type<T>::type num_type; \
            return  FunctionName##_impl(v,num_type);               \
         }                                                         \

Definition at line 1628 of file exprtk.hpp.

         {                                                         \
            const typename details::number_type<T>::type num_type; \
            return  FunctionName##_impl(v,num_type);               \
         }                                                         \
 

exprtk_define_unary_op

#define exprtk_define_unary_op

(

OpName

)

Value:

      template <typename T>                                     \
      struct OpName##_op                                        \
      {                                                         \
         typedef typename functor_t<T>::Type Type;              \
         typedef typename expression_node<T>::node_type node_t; \
                                                                \
         static inline T process(Type v)                        \
         {                                                      \
            return numeric:: OpName (v);                        \
         }                                                      \
                                                                \
         static inline node_t type()                            \
         {                                                      \
            return expression_node<T>::e_##OpName;              \
         }                                                      \
                                                                \
         static inline details::operator_type operation()       \
         {                                                      \
            return details::e_##OpName;                         \
         }                                                      \
      };                                                        \

Definition at line 14730 of file exprtk.hpp.

      {                                                         \
         typedef typename functor_t<T>::Type Type;              \
         typedef typename expression_node<T>::node_type node_t; \
                                                                \
         static inline T process(Type v)                        \
         {                                                      \
            return numeric:: OpName (v);                        \
         }                                                      \
                                                                \
         static inline node_t type()                            \
         {                                                      \
            return expression_node<T>::e_##OpName;              \
         }                                                      \
                                                                \
         static inline details::operator_type operation()       \
         {                                                      \
            return details::e_##OpName;                         \
         }                                                      \
      };                                                        \
 

exprtk_delete

#define exprtk_delete

Definition at line 77 of file exprtk.hpp.

exprtk_error_location

#define exprtk_error_location    "exprtk.hpp:" + details::to_str(__LINE__) \

Definition at line 67 of file exprtk.hpp.

              :" + details::to_str(__LINE__) \
 

exprtk_fallthrough

#define exprtk_fallthrough

Definition at line 83 of file exprtk.hpp.

exprtk_final

#define exprtk_final

Definition at line 76 of file exprtk.hpp.

exprtk_loop [1/11]

#define exprtk_loop

(

N

)

std::swap(s0[N], s1[N]); \

exprtk_loop [2/11]

#define exprtk_loop

(

N

)

vec[N] = v; \

exprtk_loop [3/11]

#define exprtk_loop

(

N

)

vec0[N] = vec1[N]; \

exprtk_loop [4/11]

#define exprtk_loop

(

N

)

Operation::assign(vec[N],v); \

exprtk_loop [5/11]

#define exprtk_loop

(

N

)

vec0[N] = Operation::process(vec0[N], vec1[N]); \

exprtk_loop [6/11]

#define exprtk_loop

(

N

)

vec2[N] = Operation::process(vec0[N], vec1[N]); \

exprtk_loop [7/11]

#define exprtk_loop

(

N

)

vec1[N] = Operation::process(vec0[N], v); \

exprtk_loop [8/11]

#define exprtk_loop

(

N

)

vec0[N] = Operation::process(v, vec1[N]); \

exprtk_loop [9/11]

#define exprtk_loop

(

N

)

vec1[N] = Operation::process(vec0[N]); \

exprtk_loop [10/11]

#define exprtk_loop

(

N

)

r[N] += vec[N]; \

exprtk_loop [11/11]

#define exprtk_loop

(

N

)

r[N] *= vec[N]; \

exprtk_override

#define exprtk_override

Definition at line 75 of file exprtk.hpp.

exprtk_process_digit

#define exprtk_process_digit

Value:

               if ((digit = (*itr++ - zero)) < 10) \
                  result = result * T(10) + digit; \
               else                                \
               {                                   \
                  return_result = false;           \
                  break;                           \
               }                                   \
               exprtk_fallthrough                  \

exprtk_register_function [1/3]

#define exprtk_register_function	(		FunctionName,
			FunctionType
	)

Value:

         if (!symtab.add_function(FunctionName,FunctionType))                     \
         {                                                                        \
            exprtk_debug((                                                        \
              "exprtk::rtl::io::register_package - Failed to add function: %s\n", \
              FunctionName));                                                     \
            return false;                                                         \
         }                                                                        \

exprtk_register_function [2/3]

#define exprtk_register_function	(		FunctionName,
			FunctionType
	)

Value:

         if (!symtab.add_function(FunctionName,FunctionType))                           \
         {                                                                              \
            exprtk_debug((                                                              \
              "exprtk::rtl::io::file::register_package - Failed to add function: %s\n", \
              FunctionName));                                                           \
            return false;                                                               \
         }                                                                              \

exprtk_register_function [3/3]

#define exprtk_register_function	(		FunctionName,
			FunctionType
	)

Value:

         if (!symtab.add_function(FunctionName,FunctionType))                         \
         {                                                                            \
            exprtk_debug((                                                            \
              "exprtk::rtl::vecops::register_package - Failed to add function: %s\n", \
              FunctionName));                                                         \
            return false;                                                             \
         }                                                                            \

exprtk_register_int_type_tag

#define exprtk_register_int_type_tag

(

T

)

Value:

            template <> struct number_type<T>                 \
            { typedef int_type_tag type; number_type() {} };  \

Definition at line 834 of file exprtk.hpp.

            { typedef int_type_tag type; number_type() {} };  \
 

exprtk_register_real_type_tag

#define exprtk_register_real_type_tag

(

T

)

Value:

            template <> struct number_type<T>                 \
            { typedef real_type_tag type; number_type() {} }; \

Definition at line 830 of file exprtk.hpp.

            { typedef real_type_tag type; number_type() {} }; \
 

extended_opr_switch_statements

#define extended_opr_switch_statements

Value:

         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 33226 of file exprtk.hpp.

igeneric_function_empty_body

#define igeneric_function_empty_body

(

N

)

Value:

      {                                              \
         exprtk_debug(("igeneric_function::operator() - Operator(" #N ") has not been overridden\n")); \
         return std::numeric_limits<T>::quiet_NaN(); \
      }                                              \

Definition at line 18993 of file exprtk.hpp.

      {                                              \
         exprtk_debug(("igeneric_function::operator() - Operator(" #N ") has not been overridden\n")); \
         return std::numeric_limits<T>::quiet_NaN(); \
      }                                              \
 

parse_digit_1

#define parse_digit_1

(

d

)

Value:

         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
         if (end == ++itr) break;          \

parse_digit_2

#define parse_digit_2

(

d

)

Value:

         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
            ++itr;                         \

pod_set_zero_value

#define pod_set_zero_value

(

T

)

Value:

      template <>                                                        \
      struct set_zero_value_impl<T>                                      \
      {                                                                  \
         static inline void process(T* base_ptr, const std::size_t size) \
         { std::memset(base_ptr, 0x00, size * sizeof(T)); }              \
      };                                                                 \

Definition at line 762 of file exprtk.hpp.

      {                                                                  \
         static inline void process(T* base_ptr, const std::size_t size) \
         { std::memset(base_ptr, 0x00, size * sizeof(T)); }              \
      };                                                                 \
 

poly_rtrn

#define poly_rtrn

(

NN

)

return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :

Definition at line 40856 of file exprtk.hpp.

                                                         :
 

register_binary_op [1/2]

#define register_binary_op	(		Op,
			BinaryFunctor
	)		m.insert(value_type(Op,BinaryFunctor<T>::process)); \

register_binary_op [2/2]

#define register_binary_op	(		Op,
			BinaryFunctor
	)		m.insert(value_type(BinaryFunctor<T>::process,Op)); \

register_op

#define register_op	(		Symbol,
			Type,
			Args
	)		m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \

register_sf3

#define register_sf3

(

Op

)

sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \

register_sf3_extid

#define register_sf3_extid	(		Id,
			Op
	)		sf3_map[Id] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \

register_sf4

#define register_sf4

(

Op

)

sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \

register_sf4ext

#define register_sf4ext

(

Op

)

sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \

register_synthezier

#define register_synthezier

(

S

)

synthesize_map_[S ::node_type::id()] = S ::process; \

register_unary_op

#define register_unary_op	(		Op,
			UnaryFunctor
	)		m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \

string_opr_switch_statements

#define string_opr_switch_statements

Value:

         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 39131 of file exprtk.hpp.

synthesis_node_type_define [1/3]

#define synthesis_node_type_define	(		T0_,
			T1_,
			T2_,
			T3_,
			v_
	)

Value:

      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 16479 of file exprtk.hpp.

                                       { 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_; \
 

synthesis_node_type_define [2/3]

#define synthesis_node_type_define	(		T0_,
			T1_,
			T2_,
			v_
	)

Value:

      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 16479 of file exprtk.hpp.

                                       { 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_; \
 

synthesis_node_type_define [3/3]

#define synthesis_node_type_define	(		T0_,
			T1_,
			v_
	)

Value:

      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 16479 of file exprtk.hpp.

                                       { 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_; \
 

token_inserter_empty_body

#define token_inserter_empty_body

Value:

         {                                 \
            return -1;                     \
         }                                 \

Definition at line 3246 of file exprtk.hpp.

         {                                 \
            return -1;                     \
         }                                 \
 

unary_opr_switch_statements

#define unary_opr_switch_statements

Definition at line 31451 of file exprtk.hpp.

vector_ops

#define vector_ops

Value:

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