expressionWalker.h File Reference

#include "unitsExpressionWalker.h"
#include <memory>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <functional>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include <sys/time.h>
#include <sys/types.h>
#include <exprtk/exprtk.hpp>

Include dependency graph for expressionWalker.h:

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

Go to the source code of this file.

Namespaces
	minsky
	exprtk
	exprtk::details
	exprtk::details::numeric

Macros
#define	exprtk_define_unary_function(Function)
#define	exprtk_define_unary_function_not_dimensionless(Function)
#define	exprtk_define_binary_function(Function)
#define	exprtk_define_binary_function_first_arg(Function)
#define	exprtk_define_binary_function_dimensionless(Function)
#define	exprtk_define_binary_op_impl(Op, def)
#define	exprtk_define_binary_op(Op, op)   exprtk_define_binary_op_impl(Op, x op y)
#define	exprtk_define_binary_fun_op(Op, f)   exprtk_define_binary_op_impl(Op, f(x,y))

Functions
bool	minsky::operator> (std::size_t x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	minsky::root (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	minsky::pow (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	minsky::checkDimensionless (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
UnitsExpressionWalker	minsky::checkSameDims (const UnitsExpressionWalker &x, const UnitsExpressionWalker &y)
bool	exprtk::details::is_true (const minsky::UnitsExpressionWalker &x)
template<>
bool	exprtk::details::string_to_real (const std::string &s, minsky::UnitsExpressionWalker &t)
	exprtk::details::numeric::exprtk_define_unary_function_not_dimensionless (abs) exprtk_define_unary_function(acos) exprtk_define_unary_function(acosh) exprtk_define_unary_function(asin) exprtk_define_unary_function(asinh) exprtk_define_unary_function(atan) exprtk_define_unary_function(atanh) exprtk_define_unary_function(ceil) exprtk_define_unary_function(cos) exprtk_define_unary_function(cosh) exprtk_define_unary_function(exp) exprtk_define_unary_function(expm1) exprtk_define_unary_function(floor) exprtk_define_unary_function(log) exprtk_define_unary_function(log10) exprtk_define_unary_function(log2) exprtk_define_unary_function(log1p) exprtk_define_unary_function_not_dimensionless(neg) exprtk_define_unary_function_not_dimensionless(pos) exprtk_define_unary_function_not_dimensionless(round) exprtk_define_unary_function(sin) exprtk_define_unary_function(sinc) exprtk_define_unary_function(sinh) exprtk_define_unary_function(tan) exprtk_define_unary_function(tanh) exprtk_define_unary_function(cot) exprtk_define_unary_function(sec) exprtk_define_unary_function(csc) exprtk_define_unary_function(r2d) exprtk_define_unary_function(d2r) exprtk_define_unary_function(d2g) exprtk_define_unary_function(g2d) exprtk_define_unary_function(notl) template<> inline minsky
	exprtk::details::numeric::exprtk_define_unary_function (erf) exprtk_define_unary_function(erfc) exprtk_define_unary_function(ncdf) exprtk_define_unary_function_not_dimensionless(frac) exprtk_define_unary_function_not_dimensionless(trunc) template<> inline minsky
template<>
int	exprtk::details::numeric::to_int32 (const minsky::UnitsExpressionWalker x)
template<>
_int64_t	exprtk::details::numeric::to_int64 (const minsky::UnitsExpressionWalker x)
template<>
bool	exprtk::details::numeric::is_integer (const minsky::UnitsExpressionWalker x)
template<>
bool	exprtk::details::numeric::is_nan (const minsky::UnitsExpressionWalker x)
	exprtk::details::numeric::exprtk_define_binary_function (min)
	exprtk::details::numeric::exprtk_define_binary_function (max)
	exprtk::details::numeric::exprtk_define_binary_function_dimensionless (equal)
	exprtk::details::numeric::exprtk_define_binary_function_dimensionless (nequal)
	exprtk::details::numeric::exprtk_define_binary_function_first_arg (modulus)
	exprtk::details::numeric::exprtk_define_binary_function (pow)
	exprtk::details::numeric::exprtk_define_binary_function (logn)
template<>
minsky::UnitsExpressionWalker	exprtk::details::numeric::root (const minsky::UnitsExpressionWalker x, const minsky::UnitsExpressionWalker y)
	exprtk::details::numeric::exprtk_define_binary_function_first_arg (roundn)
	exprtk::details::numeric::exprtk_define_binary_function (hypot)
	exprtk::details::numeric::exprtk_define_binary_function (atan2)
	exprtk::details::numeric::exprtk_define_binary_function (shr)
	exprtk::details::numeric::exprtk_define_binary_function (shl)
	exprtk::details::numeric::exprtk_define_binary_function (and_opr)
	exprtk::details::numeric::exprtk_define_binary_function (nand_opr)
	exprtk::details::numeric::exprtk_define_binary_function (or_opr)
	exprtk::details::numeric::exprtk_define_binary_function (nor_opr)
	exprtk::details::numeric::exprtk_define_binary_function (xor_opr)
	exprtk::details::numeric::exprtk_define_binary_function (xnor_opr)
	exprtk::details::exprtk_define_binary_op (add,+) exprtk_define_binary_op(sub
	exprtk::details::exprtk_define_binary_op (mul, *) exprtk_define_binary_op(div
	exprtk::details::exprtk_define_binary_op_impl (mod, x) exprtk_define_binary_fun_op(pow
pow	exprtk::details::exprtk_define_binary_fun_op (lt, checkSameDims) exprtk_define_binary_fun_op(lte
pow checkSameDims	exprtk::details::exprtk_define_binary_fun_op (gt, checkSameDims) exprtk_define_binary_fun_op(gte
pow checkSameDims checkSameDims	exprtk::details::exprtk_define_binary_fun_op (eq, checkSameDims) exprtk_define_binary_fun_op(ne
pow checkSameDims checkSameDims checkSameDims	exprtk::details::exprtk_define_binary_fun_op (and, checkSameDims) exprtk_define_binary_fun_op(nand
pow checkSameDims checkSameDims checkSameDims checkSameDims	exprtk::details::exprtk_define_binary_fun_op (or, checkSameDims) exprtk_define_binary_fun_op(nor
pow checkSameDims checkSameDims checkSameDims checkSameDims checkSameDims	exprtk::details::exprtk_define_binary_fun_op (xor, checkSameDims) exprtk_define_binary_fun_op(xnor

Macro Definition Documentation

exprtk_define_binary_fun_op

#define exprtk_define_binary_fun_op	(		Op,
			f
	)		exprtk_define_binary_op_impl(Op, f(x,y))

Definition at line 263 of file expressionWalker.h.

exprtk_define_binary_function

#define exprtk_define_binary_function

(

Function

)

Value:

template <>                                                       \
      inline minsky::UnitsExpressionWalker Function                     \
      (const minsky::UnitsExpressionWalker x, const minsky::UnitsExpressionWalker y) \
      {x.checkSameDims(y); return x;}

Definition at line 200 of file expressionWalker.h.

exprtk_define_binary_function_dimensionless

#define exprtk_define_binary_function_dimensionless

(

Function

)

Value:

template <>                                                       \
      inline minsky::UnitsExpressionWalker Function                     \
      (const minsky::UnitsExpressionWalker x, const minsky::UnitsExpressionWalker y) \
      {x.checkSameDims(y); return {};}

Definition at line 212 of file expressionWalker.h.

exprtk_define_binary_function_first_arg

#define exprtk_define_binary_function_first_arg

(

Function

)

Value:

template <>                                                       \
      inline minsky::UnitsExpressionWalker Function                     \
      (const minsky::UnitsExpressionWalker x, const minsky::UnitsExpressionWalker y) \
      {return x;}

Definition at line 206 of file expressionWalker.h.

exprtk_define_binary_op

#define exprtk_define_binary_op	(		Op,
			op
	)		exprtk_define_binary_op_impl(Op, x op y)

Definition at line 262 of file expressionWalker.h.

exprtk_define_binary_op_impl

#define exprtk_define_binary_op_impl	(		Op,
			def
	)

Value:

template <>                                                         \
    struct Op##_op<minsky::UnitsExpressionWalker>:                      \
      public opr_base<minsky::UnitsExpressionWalker>                    \
    {                                                                   \
      using T=minsky::UnitsExpressionWalker;                            \
      typedef typename opr_base<T>::Type Type;                          \
      typedef typename opr_base<T>::RefType RefType;                    \
                                                                        \
      static inline T process(Type x, Type y)                           \
      {return def;}                                                     \
      static inline void assign(RefType t1, Type t2)                    \
      {t1=t2;}                                                          \
      static inline typename expression_node<T>::node_type type()       \
      { return expression_node<T>::e_##Op; }                             \
      static inline details::operator_type operation()                  \
      { return details::e_##Op; }                                        \
    };

Definition at line 243 of file expressionWalker.h.

exprtk_define_unary_function

#define exprtk_define_unary_function

(

Function

)

Value:

template <>                                                       \
      inline minsky::UnitsExpressionWalker Function(const minsky::UnitsExpressionWalker x) \
      {x.checkDimensionless(); return x;}

Definition at line 132 of file expressionWalker.h.

exprtk_define_unary_function_not_dimensionless

#define exprtk_define_unary_function_not_dimensionless

(

Function

)

Value:

template <>                                                       \
      inline minsky::UnitsExpressionWalker Function(const minsky::UnitsExpressionWalker x) \
      {return x;}

Definition at line 137 of file expressionWalker.h.