exprtk Namespace Reference

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

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

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)

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 42328 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 42296 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 42267 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 42235 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 42641 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 42612 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 42585 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 42563 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 42472 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 42408 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 19759 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 19747 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 19753 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 19736 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 42380 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 42356 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_valid()

template<typename T >

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

inline

Definition at line 22299 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 4769 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 4762 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 42499 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 42429 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 19774 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 19765 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 42526 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 42451 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 4996 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()(), import_packages< T >::operator()(), gen_func< T >::operator()(), and exprtk::rtl::io::details::print_impl< T >::print().

Here is the caller graph for this function: