exprtk Namespace Reference

Namespaces
namespace	details
namespace	helper
namespace	information
namespace	lexer
namespace	parser_error
namespace	rtl

Classes
struct	loop_runtime_check
struct	vector_access_runtime_check
struct	assert_check
struct	compilation_check
class	vector_view
class	results_context
struct	type_store
class	function_traits
class	ifunction
class	ivararg_function
class	igeneric_function
class	stringvar_base
class	parser
class	expression_helper
class	symbol_table
class	function_compositor
class	expression
class	polynomial
class	timer
struct	type_defs

Typedefs
typedef loop_runtime_check *	loop_runtime_check_ptr
typedef vector_access_runtime_check *	vector_access_runtime_check_ptr
typedef assert_check *	assert_check_ptr
typedef compilation_check *	compilation_check_ptr

Functions
template<typename T>
vector_view< T >	make_vector_view (T *data, const std::size_t size, const std::size_t offset=0)
template<typename T>
vector_view< T >	make_vector_view (std::vector< T > &v, const std::size_t size, const std::size_t offset=0)
template<typename StringView>
std::string	to_str (const StringView &view)
template<typename FunctionType>
void	enable_zero_parameters (FunctionType &func)
template<typename FunctionType>
void	disable_zero_parameters (FunctionType &func)
template<typename FunctionType>
void	enable_has_side_effects (FunctionType &func)
template<typename FunctionType>
void	disable_has_side_effects (FunctionType &func)
template<typename FunctionType>
void	set_min_num_args (FunctionType &func, const std::size_t &num_args)
template<typename FunctionType>
void	set_max_num_args (FunctionType &func, const std::size_t &num_args)
template<typename T>
bool	is_valid (const expression< T > &expr)
template<typename Allocator, template< typename, typename > class Sequence>
bool	collect_variables (const std::string &expression, Sequence< std::string, Allocator > &symbol_list)
template<typename T, typename Allocator, template< typename, typename > class Sequence>
bool	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	collect_functions (const std::string &expression, Sequence< std::string, Allocator > &symbol_list)
template<typename T, typename Allocator, template< typename, typename > class Sequence>
bool	collect_functions (const std::string &expression, exprtk::symbol_table< T > &extrnl_symbol_table, Sequence< std::string, Allocator > &symbol_list)
template<typename T>
T	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	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	derivative (const expression< T > &e, T &x, const T &h=T(0.00000001))
template<typename T>
T	second_derivative (const expression< T > &e, T &x, const T &h=T(0.00001))
template<typename T>
T	third_derivative (const expression< T > &e, T &x, const T &h=T(0.0001))
template<typename T>
T	derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.00000001))
template<typename T>
T	second_derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.00001))
template<typename T>
T	third_derivative (const expression< T > &e, const std::string &variable_name, const T &h=T(0.0001))
template<typename T>
bool	compute (const std::string &expression_string, T &result)
template<typename T>
bool	compute (const std::string &expression_string, const T &x, T &result)
template<typename T>
bool	compute (const std::string &expression_string, const T &x, const T &y, T &result)
template<typename T>
bool	compute (const std::string &expression_string, const T &x, const T &y, const T &z, T &result)
bool	is_true (const double v)
bool	is_true (const double v)
bool	is_true (const double v)

Typedef Documentation

assert_check_ptr

typedef assert_check* exprtk::assert_check_ptr

Definition at line 2253 of file exprtk.hpp.

compilation_check_ptr

typedef compilation_check* exprtk::compilation_check_ptr

Definition at line 2268 of file exprtk.hpp.

loop_runtime_check_ptr

typedef loop_runtime_check* exprtk::loop_runtime_check_ptr

Definition at line 2210 of file exprtk.hpp.

vector_access_runtime_check_ptr

typedef vector_access_runtime_check* exprtk::vector_access_runtime_check_ptr

Definition at line 2234 of file exprtk.hpp.

Function Documentation

collect_functions() [1/2]

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 )

inline

Definition at line 42458 of file exprtk.hpp.

   {
      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;
   }

collect_functions() [2/2]

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

bool exprtk::collect_functions ( const std::string & expression, Sequence< std::string, Allocator > & symbol_list )

inline

Definition at line 42426 of file exprtk.hpp.

   {
      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;
   }

Referenced by exprtk::details::collector_helper< T >::collection_pass(), extract_expression_dependents(), and run_test10().

Here is the caller graph for this function:

collect_variables() [1/2]

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 )

inline

Definition at line 42397 of file exprtk.hpp.

   {
      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;
   }

collect_variables() [2/2]

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

bool exprtk::collect_variables ( const std::string & expression, Sequence< std::string, Allocator > & symbol_list )

inline

Definition at line 42365 of file exprtk.hpp.

   {
      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;
   }

Referenced by exprtk::details::collector_helper< T >::collection_pass(), extract_expression_dependents(), and run_test10().

Here is the caller graph for this function:

compute() [1/4]

template<typename T>

bool exprtk::compute ( const std::string & expression_string, const T & x, const T & y, const T & z, T & result )

inline

Definition at line 42771 of file exprtk.hpp.

   {
      // 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;
   }

References exprtk::symbol_table< T >::add_constant(), exprtk::symbol_table< T >::add_constants(), exprtk::parser< T >::compile(), exprtk::expression< T >::register_symbol_table(), and exprtk::expression< T >::value().

Here is the call graph for this function:

compute() [2/4]

template<typename T>

bool exprtk::compute ( const std::string & expression_string, const T & x, const T & y, T & result )

inline

Definition at line 42742 of file exprtk.hpp.

   {
      // 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;
   }

References exprtk::symbol_table< T >::add_constant(), exprtk::symbol_table< T >::add_constants(), exprtk::parser< T >::compile(), exprtk::expression< T >::register_symbol_table(), and exprtk::expression< T >::value().

Here is the call graph for this function:

compute() [3/4]

template<typename T>

bool exprtk::compute ( const std::string & expression_string, const T & x, T & result )

inline

Definition at line 42715 of file exprtk.hpp.

   {
      // 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;
   }

References exprtk::symbol_table< T >::add_constant(), exprtk::symbol_table< T >::add_constants(), exprtk::parser< T >::compile(), exprtk::expression< T >::register_symbol_table(), and exprtk::expression< T >::value().

Here is the call graph for this function:

compute() [4/4]

template<typename T>

bool exprtk::compute ( const std::string & expression_string, T & result )

inline

Definition at line 42693 of file exprtk.hpp.

   {
      // 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;
   }

References exprtk::symbol_table< T >::add_constants(), exprtk::parser< T >::compile(), exprtk::expression< T >::register_symbol_table(), and exprtk::expression< T >::value().

Here is the call graph for this function:

derivative() [1/2]

template<typename T>

T exprtk::derivative ( const expression< T > & e, const std::string & variable_name, const T & h = T(0.00000001) )

inline

Definition at line 42602 of file exprtk.hpp.

   {
      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();
   }

References derivative(), exprtk::symbol_table< T >::get_variable(), exprtk::details::variable_node< T >::ref(), and exprtk::symbol_table< T >::valid().

Here is the call graph for this function:

derivative() [2/2]

template<typename T>

T exprtk::derivative ( const expression< T > & e, T & x, const T & h = T(0.00000001) )

inline

Definition at line 42538 of file exprtk.hpp.

   {
      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);
   }

Referenced by derivative(), and run_test07().

Here is the caller graph for this function:

disable_has_side_effects()

template<typename FunctionType>

void exprtk::disable_has_side_effects

(

FunctionType &

func

)

Definition at line 19839 of file exprtk.hpp.

   {
      func.has_side_effects() = false;
   }

Referenced by myfunc< T >::myfunc(), and exprtk::polynomial< T, N >::polynomial().

Here is the caller graph for this function:

disable_zero_parameters()

template<typename FunctionType>

void exprtk::disable_zero_parameters

(

FunctionType &

func

)

Definition at line 19827 of file exprtk.hpp.

   {
      func.allow_zero_parameters() = false;
   }

enable_has_side_effects()

template<typename FunctionType>

void exprtk::enable_has_side_effects

(

FunctionType &

func

)

Definition at line 19833 of file exprtk.hpp.

   {
      func.has_side_effects() = true;
   }

enable_zero_parameters()

template<typename FunctionType>

void exprtk::enable_zero_parameters

(

FunctionType &

func

)

Definition at line 19816 of file exprtk.hpp.

   {
      func.allow_zero_parameters() = true;
 
      if (0 != func.min_num_args())
      {
         func.min_num_args() = 0;
      }
   }

Referenced by exprtk::rtl::io::print< T >::print(), exprtk::rtl::io::println< T >::println(), and va_func< T >::va_func().

Here is the caller graph for this function:

integrate() [1/2]

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 )

inline

Definition at line 42510 of file exprtk.hpp.

   {
      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();
   }

References exprtk::symbol_table< T >::get_variable(), integrate(), exprtk::details::variable_node< T >::ref(), and exprtk::symbol_table< T >::valid().

Here is the call graph for this function:

integrate() [2/2]

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 )

inline

Definition at line 42486 of file exprtk.hpp.

   {
      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;
   }

Referenced by integrate(), and run_test06().

Here is the caller graph for this function:

is_true() [1/3]

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

inline

Definition at line 5763 of file exprtk.hpp.

      {
         return std::not_equal_to<double>()(0.0,v);
      }

is_true() [2/3]

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

inline

Definition at line 5763 of file exprtk.hpp.

      {
         return std::not_equal_to<double>()(0.0,v);
      }

is_true() [3/3]

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

inline

Definition at line 5763 of file exprtk.hpp.

      {
         return std::not_equal_to<double>()(0.0,v);
      }

is_valid()

template<typename T>

bool exprtk::is_valid ( const expression< T > & expr )

inline

Definition at line 22383 of file exprtk.hpp.

   {
      return expr.control_block_ && !expression_helper<T>::is_null(expr);
   }

References exprtk::expression< T >::control_block_, and exprtk::expression_helper< T >::is_null().

Here is the call graph for this function:

make_vector_view() [1/2]

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 )

inline

Definition at line 4790 of file exprtk.hpp.

   {
      return vector_view<T>(v.data() + offset, size);
   }

make_vector_view() [2/2]

template<typename T>

vector_view< T > exprtk::make_vector_view ( T * data, const std::size_t size, const std::size_t offset = 0 )

inline

Definition at line 4783 of file exprtk.hpp.

   {
      return vector_view<T>(data + offset, size);
   }

Referenced by run_test01(), run_test18(), run_test21(), vector_inline_resize_example(), and vector_resize_example().

Here is the caller graph for this function:

second_derivative() [1/2]

template<typename T>

T exprtk::second_derivative ( const expression< T > & e, const std::string & variable_name, const T & h = T(0.00001) )

inline

Definition at line 42629 of file exprtk.hpp.

   {
      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();
   }

References exprtk::symbol_table< T >::get_variable(), exprtk::details::variable_node< T >::ref(), second_derivative(), and exprtk::symbol_table< T >::valid().

Here is the call graph for this function:

second_derivative() [2/2]

template<typename T>

T exprtk::second_derivative ( const expression< T > & e, T & x, const T & h = T(0.00001) )

inline

Definition at line 42559 of file exprtk.hpp.

   {
      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);
   }

Referenced by run_test07(), and second_derivative().

Here is the caller graph for this function:

set_max_num_args()

template<typename FunctionType>

void exprtk::set_max_num_args	(	FunctionType &	func,
		const std::size_t &	num_args )

Definition at line 19854 of file exprtk.hpp.

   {
      func.max_num_args() = num_args;
   }

Referenced by va_func< T >::va_func().

Here is the caller graph for this function:

set_min_num_args()

template<typename FunctionType>

void exprtk::set_min_num_args	(	FunctionType &	func,
		const std::size_t &	num_args )

Definition at line 19845 of file exprtk.hpp.

   {
      func.min_num_args() = num_args;
 
      if ((0 != func.min_num_args()) && func.allow_zero_parameters())
         func.allow_zero_parameters() = false;
   }

Referenced by va_func< T >::va_func().

Here is the caller graph for this function:

third_derivative() [1/2]

template<typename T>

T exprtk::third_derivative ( const expression< T > & e, const std::string & variable_name, const T & h = T(0.0001) )

inline

Definition at line 42656 of file exprtk.hpp.

   {
      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();
   }

References exprtk::symbol_table< T >::get_variable(), exprtk::details::variable_node< T >::ref(), third_derivative(), and exprtk::symbol_table< T >::valid().

Here is the call graph for this function:

third_derivative() [2/2]

template<typename T>

T exprtk::third_derivative ( const expression< T > & e, T & x, const T & h = T(0.0001) )

inline

Definition at line 42581 of file exprtk.hpp.

   {
      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);
   }

Referenced by run_test07(), and third_derivative().

Here is the caller graph for this function:

to_str()

template<typename StringView>

std::string exprtk::to_str ( const StringView & view )

inline

Definition at line 5017 of file exprtk.hpp.

   {
      return std::string(view.begin(),view.size());
   }

Referenced by exprtk::rtl::io::file::open< T >::operator()(), exprtk::rtl::vecops::sort< T >::operator()(), gen_func< T >::operator()(), import_packages< T >::operator()(), and exprtk::rtl::io::details::print_impl< T >::print().

Here is the caller graph for this function: