NimbleSM
NimbleSM is a solid mechanics simulation code for dynamic systems
Loading...
Searching...
No Matches
Classes | Namespaces | Macros | Typedefs | Functions | Variables
nimble_expression_parser.h File Reference
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <stdexcept>
#include <typeinfo>
#include <map>
#include <string>

Go to the source code of this file.

Classes

struct  ExpressionParsing::DeletableObjectBaseClass
 
class  ExpressionParsing::MemoryManager
 
struct  ExpressionParsing::MemoryManager::MemoryBlock
 
struct  ExpressionParsing::Evaluatable< T >
 
struct  ExpressionParsing::GenericConstant< T >
 
struct  ExpressionParsing::GenericReference< T >
 
struct  ExpressionParsing::Reader
 
class  ExpressionParsing::EquationContext
 
struct  ExpressionParsing::BoundaryConditionFunctor
 

Namespaces

namespace  ExpressionParsing
 

Macros

#define MakeGenericFunction(GenericFunction, f)
 
#define MakeGenericOperator(name, operation)
 
#define MakeGenericTwoInputFunc(name, f)
 

Typedefs

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

Functions

 ExpressionParsing::MakeGenericFunction (GenericSin, std::sin) MakeGenericFunction(GenericCos
 
std::cos ExpressionParsing::MakeGenericFunction (GenericTan, std::tan) MakeGenericFunction(GenericErf
 
std::cos std::erf ExpressionParsing::MakeGenericFunction (GenericExp, std::exp) MakeGenericFunction(GenericLog
 
std::cos std::erf std::log ExpressionParsing::MakeGenericFunction (GenericAbs, std::abs) MakeGenericFunction(GenericASin
 
std::cos std::erf std::log std::asin ExpressionParsing::MakeGenericFunction (GenericACos, std::acos) MakeGenericFunction(GenericATan
 
std::cos std::erf std::log std::asin std::atan ExpressionParsing::MakeGenericFunction (GenericSqrt, std::sqrt) MakeGenericFunction(GenericCbrt
 
std::cos std::erf std::log std::asin std::atan std::cbrt ExpressionParsing::MakeGenericFunction (GenericErfc, std::erfc) MakeGenericFunction(GenericCeil
 
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil ExpressionParsing::MakeGenericFunction (GenericRound, std::round) MakeGenericFunction(GenericFloor
 
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericFunction (GenericLog10, std::log10) MakeGenericFunction(GenericNeg
 
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericFunction (GenericNot, !) MakeGenericOperator(GenericAdd
 
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericOperator (GenericMultiply, *) MakeGenericOperator(GenericDivide
 
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::MakeGenericOperator (GenericSubtract, -) MakeGenericOperator(GenericGreater
 
std::cos std::erf std::log std::asin std::atan std::cbrt std::ceil std::floor ExpressionParsing::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 ExpressionParsing::optimize (m)
 
 ExpressionParsing::if (auto ConstCondition=dynamic_cast< GenericConstant< bool > * >(condition))
 
bool ExpressionParsing::IsCMathFunc (Reader r)
 
RealValuedExpression * ExpressionParsing::GetCMathFunc (Reader r, RealValuedExpression *input, MemoryManager &m)
 
bool ExpressionParsing::IsDigit (char c)
 
bool ExpressionParsing::IsInteger (Reader r)
 
bool ExpressionParsing::IsNumber (Reader r)
 
void ExpressionParsing::ConvertStringToLowercase (std::string &s)
 
void ExpressionParsing::RemoveWhitespace (Reader &text)
 
void ExpressionParsing::RemoveRedundantParenthesis (Reader &text)
 
void ExpressionParsing::ApplyNecessaryFormatting (Reader &text)
 

Variables

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

Macro Definition Documentation

◆ MakeGenericFunction

#define MakeGenericFunction ( GenericFunction,
f )
Value:
template <typename Out, typename In> \
struct GenericFunction : Evaluatable<Out> \
{ \
struct ReferenceCase : Evaluatable<Out> \
{ \
In* input1; \
operator Out() const { return f(*input1); } \
ReferenceCase(In* in1) : input1(in1) {} \
}; \
Evaluatable<In>* input1; \
operator Out() const { return f(*input1); } \
GenericFunction(Evaluatable<In>* in1) : input1(in1) {} \
Evaluatable<Out>* \
optimize(MemoryManager& m) \
{ \
Evaluatable<In>* in1 = this->input1->optimize(m); \
if (GenericConstant<In>* constant = dynamic_cast<GenericConstant<In>*>(in1)) { \
return m.New<GenericConstant<Out>>(f(*in1)); \
} else if (GenericReference<In>* reference = dynamic_cast<GenericReference<In>*>(in1)) { \
return m.New<ReferenceCase>(reference->value); \
} \
this->input1 = in1; \
return this; \
} \
};
152#define MakeGenericFunction(GenericFunction, f) \
153 template <typename Out, typename In> \
154 struct GenericFunction : Evaluatable<Out> \
155 { \
156 struct ReferenceCase : Evaluatable<Out> \
157 { \
158 In* input1; \
159 operator Out() const { return f(*input1); } \
160 ReferenceCase(In* in1) : input1(in1) {} \
161 }; \
162 Evaluatable<In>* input1; \
163 operator Out() const { return f(*input1); } \
164 GenericFunction(Evaluatable<In>* in1) : input1(in1) {} \
165 Evaluatable<Out>* \
166 optimize(MemoryManager& m) \
167 { \
168 Evaluatable<In>* in1 = this->input1->optimize(m); \
169 if (GenericConstant<In>* constant = dynamic_cast<GenericConstant<In>*>(in1)) { \
170 return m.New<GenericConstant<Out>>(f(*in1)); \
171 } else if (GenericReference<In>* reference = dynamic_cast<GenericReference<In>*>(in1)) { \
172 return m.New<ReferenceCase>(reference->value); \
173 } \
174 this->input1 = in1; \
175 return this; \
176 } \
177 };

◆ MakeGenericOperator

#define MakeGenericOperator ( name,
operation )
179#define MakeGenericOperator(name, operation) \
180 template <typename Out, typename In1, typename In2> \
181 struct name : Evaluatable<Out> \
182 { \
183 template <typename In1_t, typename In2_t> \
184 struct ReferenceCase : Evaluatable<Out> \
185 { \
186 In1_t* input1; \
187 In2_t* input2; \
188 operator Out() const { return (*input1)operation(*input2); } \
189 ReferenceCase(In1_t* in1, In2_t* in2) : input1(in1), input2(in2) {} \
190 }; \
191 template <typename In2_type> \
192 struct ConstCase1 : Evaluatable<Out> \
193 { \
194 In1 input1; \
195 In2_type* input2; \
196 operator Out() const { return input1 operation(*input2); } \
197 ConstCase1(In1 in1, In2_type* in2) : input1(in1), input2(in2) {} \
198 }; \
199 template <typename In1_type> \
200 struct ConstCase2 : Evaluatable<Out> \
201 { \
202 In1_type* input1; \
203 In2 input2; \
204 operator Out() const { return (*input1)operation input2; } \
205 ConstCase2(In1_type* in1, In2 in2) : input1(in1), input2(in2) {} \
206 }; \
207 Evaluatable<In1>* input1; \
208 Evaluatable<In2>* input2; \
209 operator Out() const { return (*input1)operation(*input2); } \
210 name(Evaluatable<In1>* in1, Evaluatable<In2>* in2) : input1(in1), input2(in2) {} \
211 Evaluatable<Out>* \
212 optimize(MemoryManager& m) \
213 { \
214 Evaluatable<In1>* input1 = this->input1->optimize(m); \
215 Evaluatable<In2>* input2 = this->input2->optimize(m); \
216 if (auto const1 = dynamic_cast<GenericConstant<In1>*>(input1)) { \
217 if (auto const2 = dynamic_cast<GenericConstant<In2>*>(input2)) \
218 return m.New<GenericConstant<Out>>((*input1)operation(*input2)); \
219 else if (auto ref2 = dynamic_cast<GenericReference<In2>*>(input2)) \
220 return m.New<ConstCase1<In2>>(const1->value, ref2->value); \
221 else \
222 return m.New<ConstCase1<Evaluatable<In2>>>(const1->value, input2); \
223 } else if (auto ref1 = dynamic_cast<GenericReference<In1>*>(input1)) { \
224 if (auto const2 = dynamic_cast<GenericConstant<In2>*>(input2)) \
225 return m.New<ConstCase2<In1>>(ref1->value, const2->value); \
226 else if (auto ref2 = dynamic_cast<GenericReference<In2>*>(input2)) \
227 return m.New<ReferenceCase<In1, In2>>(ref1->value, ref2->value); \
228 else \
229 return m.New<ReferenceCase<In1, Evaluatable<In2>>>(ref1->value, input2); \
230 } else if (auto const2 = dynamic_cast<GenericConstant<In2>*>(input2)) \
231 return m.New<ConstCase2<Evaluatable<In1>>>(input1, const2->value); \
232 else if (auto ref2 = dynamic_cast<GenericReference<In2>*>(input2)) \
233 return m.New<ReferenceCase<Evaluatable<In1>, In2>>(input1, ref2->value); \
234 this->input1 = input1; \
235 this->input2 = input2; \
236 return this; \
237 } \
238 };

◆ MakeGenericTwoInputFunc

#define MakeGenericTwoInputFunc ( name,
f )
240#define MakeGenericTwoInputFunc(name, f) \
241 template <typename Out, typename In1, typename In2> \
242 struct name : Evaluatable<Out> \
243 { \
244 template <typename In1_t, typename In2_t> \
245 struct ReferenceCase : Evaluatable<Out> \
246 { \
247 In1_t* input1; \
248 In2_t* input2; \
249 operator Out() const { return f(*input1, *input2); } \
250 ReferenceCase(In1_t* in1, In2_t* in2) : input1(in1), input2(in2) {} \
251 }; \
252 template <typename In2_type> \
253 struct ConstCase1 : Evaluatable<Out> \
254 { \
255 In1 input1; \
256 In2_type* input2; \
257 operator Out() const { return f(input1, *input2); } \
258 ConstCase1(In1 in1, In2_type* in2) : input1(in1), input2(in2) {} \
259 }; \
260 template <typename In1_type> \
261 struct ConstCase2 : Evaluatable<Out> \
262 { \
263 In1_type* input1; \
264 In2 input2; \
265 operator Out() const { return f(*input1, input2); } \
266 ConstCase2(In1_type* in1, In2 in2) : input1(in1), input2(in2) {} \
267 }; \
268 Evaluatable<In1>* input1; \
269 Evaluatable<In2>* input2; \
270 operator Out() const { return f(*input1, *input2); } \
271 name(Evaluatable<In1>* in1, Evaluatable<In2>* in2) : input1(in1), input2(in2) {} \
272 Evaluatable<Out>* \
273 optimize(MemoryManager& m) \
274 { \
275 Evaluatable<In1>* input1 = this->input1->optimize(m); \
276 Evaluatable<In2>* input2 = this->input2->optimize(m); \
277 if (auto const1 = dynamic_cast<GenericConstant<In1>*>(input1)) { \
278 if (auto const2 = dynamic_cast<GenericConstant<In2>*>(input2)) \
279 return m.New<GenericConstant<Out>>(f(*input1, *input2)); \
280 else if (auto ref2 = dynamic_cast<GenericReference<In2>*>(input2)) \
281 return m.New<ConstCase1<In2>>(const1->value, ref2->value); \
282 else \
283 return m.New<ConstCase1<Evaluatable<In2>>>(const1->value, input2); \
284 } else if (auto ref1 = dynamic_cast<GenericReference<In1>*>(input1)) { \
285 if (auto const2 = dynamic_cast<GenericConstant<In2>*>(input2)) \
286 return m.New<ConstCase2<In1>>(ref1->value, const2->value); \
287 else if (auto ref2 = dynamic_cast<GenericReference<In2>*>(input2)) \
288 return m.New<ReferenceCase<In1, In2>>(ref1->value, ref2->value); \
289 else \
290 return m.New<ReferenceCase<In1, Evaluatable<In2>>>(ref1->value, input2); \
291 } else if (auto const2 = dynamic_cast<GenericConstant<In2>*>(input2)) \
292 return m.New<ConstCase2<Evaluatable<In1>>>(input1, const2->value); \
293 else if (auto ref2 = dynamic_cast<GenericReference<In2>*>(input2)) \
294 return m.New<ReferenceCase<Evaluatable<In1>, In2>>(input1, ref2->value); \
295 this->input1 = input1; \
296 this->input2 = input2; \
297 return this; \
298 } \
299 };
Generated by doxygen 1.13.2