ExpressionParsing Namespace Reference

Classes
struct	BoundaryConditionFunctor
struct	DeletableObjectBaseClass
class	EquationContext
struct	Evaluatable
struct	GenericConstant
struct	GenericReference
class	MemoryManager
struct	Reader

Typedefs
typedef Evaluatable< double >	RealValuedExpression
typedef GenericConstant< double >	DoubleConstant
typedef GenericAdd< double, double, double >	DoubleAdd
typedef GenericSubtract< double, double, double >	DoubleSubtract
typedef GenericMultiply< double, double, double >	DoubleMultiply
typedef GenericDivide< double, double, double >	DoubleDivide
typedef GenericPow< double, double, double >	DoublePow
typedef GenericMod< double, double, double >	DoubleMod
typedef GenericPow< double, double, int >	DoubleToIntegerPow
typedef Evaluatable< bool >	BooleanExpression
typedef GenericConstant< bool >	BooleanConstant
typedef Conditional< double >	RealValuedConditional

Functions
	MakeGenericFunction (GenericSin, std::sin) MakeGenericFunction(GenericCos
std::cos	MakeGenericFunction (GenericTan, std::tan) MakeGenericFunction(GenericErf
std::cos std::erf	MakeGenericFunction (GenericExp, std::exp) MakeGenericFunction(GenericLog
std::cos std::erf std::log	MakeGenericFunction (GenericAbs, std::abs) MakeGenericFunction(GenericASin
std::cos std::erf std::log std::asin	MakeGenericFunction (GenericACos, std::acos) MakeGenericFunction(GenericATan
std::cos std::erf std::log std::asin std::atan	MakeGenericFunction (GenericSqrt, std::sqrt) MakeGenericFunction(GenericCbrt
std::cos std::erf std::log std::asin std::atan std::cbrt	MakeGenericFunction (GenericErfc, std::erfc) MakeGenericFunction(GenericCeil
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil	MakeGenericFunction (GenericRound, std::round) MakeGenericFunction(GenericFloor
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor	MakeGenericFunction (GenericLog10, std::log10) MakeGenericFunction(GenericNeg
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor	MakeGenericFunction (GenericNot, !) MakeGenericOperator(GenericAdd
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor	MakeGenericOperator (GenericMultiply, *) MakeGenericOperator(GenericDivide
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor	MakeGenericOperator (GenericSubtract, -) MakeGenericOperator(GenericGreater
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor	MakeGenericOperator (GenericGreaterOrEqual, >=) MakeGenericOperator(GenericLess
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor<) MakeGenericOperator(GenericLessOrEqual,<=) MakeGenericOperator(GenericEqual,==) MakeGenericOperator(GenericInequal, !=) MakeGenericOperator(GenericAnd, &&) MakeGenericOperator(GenericXor, xor) MakeGenericOperator(GenericOr,||) MakeGenericTwoInputFunc(GenericPow, std::pow) MakeGenericTwoInputFunc(GenericMod, std::fmod) template< typename Out > struct Conditional :Evaluatable< Out > { Evaluatable< bool > *condition;Evaluatable< Out > *IfTrue;Evaluatable< Out > *IfFalse;operator Out() const { return(*condition) ?(*IfTrue) :(*IfFalse);} Conditional(Evaluatable< bool > *condition, Evaluatable< Out > *WhenTrue, Evaluatable< Out > *WhenFalse) :condition(condition), IfTrue(WhenTrue), IfFalse(WhenFalse) { } Evaluatable< Out > *optimize(MemoryManager &m) { Evaluatable< bool > *condition=this-> condition	optimize (m)
	if (auto ConstCondition=dynamic_cast< GenericConstant< bool > * >(condition))
bool	IsCMathFunc (Reader r)
RealValuedExpression *	GetCMathFunc (Reader r, RealValuedExpression *input, MemoryManager &m)
bool	IsDigit (char c)
bool	IsInteger (Reader r)
bool	IsNumber (Reader r)
void	ConvertStringToLowercase (std::string &s)
void	RemoveWhitespace (Reader &text)
void	RemoveRedundantParenthesis (Reader &text)
void	ApplyNecessaryFormatting (Reader &text)

Variables
Evaluatable< Out > *	IfTrue = this->IfTrue->optimize(m)
Evaluatable< Out > *	IfFalse = this->IfFalse->optimize(m)
this	condition = condition
return	this

Typedef Documentation

BooleanConstant

typedef GenericConstant<bool> ExpressionParsing::BooleanConstant

BooleanExpression

typedef Evaluatable<bool> ExpressionParsing::BooleanExpression

DoubleAdd

typedef GenericAdd<double, double, double> ExpressionParsing::DoubleAdd

DoubleConstant

typedef GenericConstant<double> ExpressionParsing::DoubleConstant

DoubleDivide

typedef GenericDivide<double, double, double> ExpressionParsing::DoubleDivide

DoubleMod

typedef GenericMod<double, double, double> ExpressionParsing::DoubleMod

DoubleMultiply

typedef GenericMultiply<double, double, double> ExpressionParsing::DoubleMultiply

DoublePow

typedef GenericPow<double, double, double> ExpressionParsing::DoublePow

DoubleSubtract

typedef GenericSubtract<double, double, double> ExpressionParsing::DoubleSubtract

DoubleToIntegerPow

typedef GenericPow<double, double, int> ExpressionParsing::DoubleToIntegerPow

RealValuedConditional

typedef Conditional<double> ExpressionParsing::RealValuedConditional

RealValuedExpression

typedef Evaluatable<double> ExpressionParsing::RealValuedExpression

Function Documentation

ApplyNecessaryFormatting()

void ExpressionParsing::ApplyNecessaryFormatting

(

ExpressionParsing::Reader &

text

)

{
  if (text.IsEmpty()) return;
  RemoveWhitespace(text);
  RemoveRedundantParenthesis(text);
}

ConvertStringToLowercase()

void ExpressionParsing::ConvertStringToLowercase

(

std::string &

s

)

{
  int   len = s.size();
  char* c   = (char*)s.c_str();
  for (int i = 0; i < len; i++) {
    if (c[i] >= 'A' && c[i] <= 'Z') c[i] += 32;
  }
}

GetCMathFunc()

ExpressionParsing::RealValuedExpression * ExpressionParsing::GetCMathFunc	(	ExpressionParsing::Reader	r,
		ExpressionParsing::RealValuedExpression *	input,
		ExpressionParsing::MemoryManager &	m )

{
  if (r == "sin") return m.New<GenericSin<double, double>>(input);
  if (r == "cos") return m.New<GenericCos<double, double>>(input);
  if (r == "tan") return m.New<GenericTan<double, double>>(input);
  if (r == "erf") return m.New<GenericErf<double, double>>(input);
  if (r == "exp") return m.New<GenericExp<double, double>>(input);
  if (r == "log") return m.New<GenericLog<double, double>>(input);
  if (r == "abs") return m.New<GenericAbs<double, double>>(input);
  if (r == "asin") return m.New<GenericASin<double, double>>(input);
  if (r == "acos") return m.New<GenericACos<double, double>>(input);
  if (r == "atan") return m.New<GenericATan<double, double>>(input);
  if (r == "sqrt") return m.New<GenericSqrt<double, double>>(input);
  if (r == "cbrt") return m.New<GenericCbrt<double, double>>(input);
  if (r == "erfc") return m.New<GenericErfc<double, double>>(input);
  if (r == "ceil") return m.New<GenericCeil<double, double>>(input);
  if (r == "round") return m.New<GenericRound<double, double>>(input);
  if (r == "floor") return m.New<GenericFloor<double, double>>(input);
  if (r == "log10") return m.New<GenericLog10<double, double>>(input);
  return 0;
}

if()

ExpressionParsing::if

(

auto

ConstCondition = dynamic_cast<GenericConstant<bool>*>(condition)

)

                                                                               {
      if (ConstCondition->value) {
        return IfTrue;
      } else
        return IfFalse;
    }

IsCMathFunc()

bool ExpressionParsing::IsCMathFunc

(

ExpressionParsing::Reader

r

)

{
  if (r == "sin" || r == "cos" || r == "tan" || r == "erf" || r == "exp" || r == "log" || r == "abs" || r == "asin" ||
      r == "acos" || r == "atan" || r == "sqrt" || r == "cbrt" || r == "erfc" || r == "ceil" || r == "round" ||
      r == "floor" || r == "log10")
    return true;
  return false;
}

IsDigit()

bool ExpressionParsing::IsDigit

(

char

c

)

{
  return c >= '0' && c <= '9';
}

IsInteger()

bool ExpressionParsing::IsInteger

(

ExpressionParsing::Reader

r

)

{
  if (r.IsEmpty()) return false;
  int len = r.length;
  if (len == 1 && (r[0] == '-' || r[0] == '+')) return false;
  if (r[0] != '-' && r[0] != '+' && !IsDigit(r[0])) return false;
  for (int i = 1; i < len; i++)
    if (!IsDigit(r[i])) return false;
  return true;
}

IsNumber()

bool ExpressionParsing::IsNumber

(

ExpressionParsing::Reader

r

)

{
  if (r.length == 0) return false;
  r.pos        = 0;
  bool decimal = false;
  bool digits  = false;
  if (r == '-' || r == '+') r.pos++;
  while (r.pos < r.length) {
    char c = r;
    r.pos++;
    if (IsDigit(c)) {
      digits = true;
      continue;
    }
    if (c == '.' && !decimal) {
      decimal = true;
      continue;
    }
    if (c == 'e' && digits) { return IsInteger(r.sub(r.pos, r.length)); }
    return false;
  }
  return true;
}

MakeGenericFunction() [1/10]

std::cos std::erf std::log ExpressionParsing::MakeGenericFunction	(	GenericAbs	,
		std::abs	)

MakeGenericFunction() [2/10]

std::cos std::erf std::log std::asin ExpressionParsing::MakeGenericFunction	(	GenericACos	,
		std::acos	)

MakeGenericFunction() [3/10]

std::cos std::erf std::log std::asin std::atan std::cbrt ExpressionParsing::MakeGenericFunction	(	GenericErfc	,
		std::erfc	)

MakeGenericFunction() [4/10]

std::cos std::erf ExpressionParsing::MakeGenericFunction	(	GenericExp	,
		std::exp	)

MakeGenericFunction() [5/10]

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericFunction	(	GenericLog10	,
		std::log10	)

MakeGenericFunction() [6/10]

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericFunction	(	GenericNot	,
		!	)

MakeGenericFunction() [7/10]

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil ExpressionParsing::MakeGenericFunction	(	GenericRound	,
		std::round	)

MakeGenericFunction() [8/10]

ExpressionParsing::MakeGenericFunction	(	GenericSin	,
		std::sin	)

MakeGenericFunction() [9/10]

std::cos std::erf std::log std::asin std::atan ExpressionParsing::MakeGenericFunction	(	GenericSqrt	,
		std::sqrt	)

MakeGenericFunction() [10/10]

std::cos ExpressionParsing::MakeGenericFunction	(	GenericTan	,
		std::tan	)

MakeGenericOperator() [1/3]

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericOperator	(	GenericGreaterOrEqual	,
		>=	)

MakeGenericOperator() [2/3]

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericOperator	(	GenericMultiply	,
		*	)

MakeGenericOperator() [3/3]

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericOperator	(	GenericSubtract	,
		-	)

optimize()

std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor<) MakeGenericOperator(GenericLessOrEqual,<=) MakeGenericOperator(GenericEqual,==) MakeGenericOperator(GenericInequal, !=) MakeGenericOperator(GenericAnd, &&) MakeGenericOperator(GenericXor, xor) MakeGenericOperator(GenericOr,||) MakeGenericTwoInputFunc(GenericPow, std::pow) MakeGenericTwoInputFunc(GenericMod, std::fmod) template< typename Out > struct Conditional :Evaluatable< Out > { Evaluatable< bool > *condition;Evaluatable< Out > *IfTrue;Evaluatable< Out > *IfFalse;operator Out() const { return(*condition) ?(*IfTrue) :(*IfFalse);} Conditional(Evaluatable< bool > *condition, Evaluatable< Out > *WhenTrue, Evaluatable< Out > *WhenFalse) :condition(condition), IfTrue(WhenTrue), IfFalse(WhenFalse) { } Evaluatable< Out > *optimize(MemoryManager &m) { Evaluatable< bool > *condition=this-> condition ExpressionParsing::optimize

(

m

)

RemoveRedundantParenthesis()

void ExpressionParsing::RemoveRedundantParenthesis

(

ExpressionParsing::Reader &

text

)

{
  text.pos = 0;
  while (text == '(') {
    text.Next('(', ')');  // Jumps to the closing parenthesis
    if (text.pos == text.length - 1) {
      text.first++;
      text.length -= 2;
      text.pos = 0;
    } else {
      text.pos = 0;
      break;
    }
  }
}

RemoveWhitespace()

void ExpressionParsing::RemoveWhitespace

(

ExpressionParsing::Reader &

text

)

{
  const char* first = text.first;
  const char* last  = first + text.length - 1;
  if (*first != ' ' && *last != ' ') return;
  while (*first == ' ' && first < last) first++;
  while (*last == ' ' && last > first) last--;
  text.first  = first;
  text.length = (last - first + 1);
  return;
}

Variable Documentation

condition

this ExpressionParsing::condition = condition

IfFalse

this ExpressionParsing::IfFalse = this->IfFalse->optimize(m)

IfTrue

this ExpressionParsing::IfTrue = this->IfTrue->optimize(m)

this

return ExpressionParsing::this