expression.h

Go to the documentation of this file.

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland-model.org
**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl
**
**    This program is free software: you can redistribute it and/or modify
**    it under the terms of the GNU General Public License as published by
**    the Free Software Foundation, either version 3 of the License, or
**    (at your option) any later version.
**
**    This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program.  If not, see <http://www.gnu.org/licenses/>.
********************************************************************************************/
 
#ifndef LOGICEXPRESSION_H
#define LOGICEXPRESSION_H
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QMutexLocker>
#include <QtCore/QVector>
 
class ExpressionWrapper;
class Expression
{
public:
        ~Expression();
        Expression();
        Expression(const QString &aExpression) { m_expr=nullptr; m_execList=nullptr; setExpression(aExpression); }
        Expression(const QString &expression, ExpressionWrapper *wrapper) { m_expr=nullptr; m_execList=nullptr; setExpression(expression); mModelObject = wrapper;  }
        // intialization
        void setExpression(const QString &aExpression); 
        void setAndParse(const QString &expr); 
        void setModelObject(ExpressionWrapper *wrapper) { mModelObject = wrapper; }
        const QString &expression() const { return m_expression; }
        void  parse(ExpressionWrapper *wrapper=nullptr); 
 
        void linearize(const double low_value, const double high_value, const int steps=1000);
        void linearize2d(const double low_x, const double high_x, const double low_y, const double high_y, const int stepsx=50, const int stepsy=50);
 
        static void setLinearizationEnabled(const bool enable) {mLinearizationAllowed = enable; }
        // calculations
        double execute(double *varlist=nullptr, ExpressionWrapper *object=nullptr) const; 
        bool executeBool(double *varlist=nullptr, ExpressionWrapper *object=nullptr) const { return execute(varlist, object) != 0.; }
        double executeLocked() { QMutexLocker m(&m_execMutex); return execute();  } 
        double calculate(const double Val1=0., const double Val2=0., const bool forceExecution=false) const;
        bool calculateBool(const double Val1=0., const double Val2=0., const bool forceExecution=false) const { return calculate(Val1, Val2, forceExecution) != 0.; }
        double calculate(ExpressionWrapper &object, const double variable_value1=0., const double variable_value2=0.) const;
        double calculateBool(ExpressionWrapper &object, const double variable_value1=0., const double variable_value2=0.) const { return calculate(object,variable_value1, variable_value2)!=0.; }
 
        //variables
        void  setVar(const QString& Var, double Value);
        double *addVar(const QString& VarName);
        double *  getVarAdress(const QString& VarName);
 
 
        bool isConstExpression() const { return m_constExpression; } 
        bool isEmpty() const { return m_empty; } 
        const QString &lastError() const { return m_errorMsg; }
        bool isStrict() { return m_strict;}
        void setStrict(bool str) { m_strict=str; }
        void setCatchExceptions(bool docatch=true) { m_catchExceptions = docatch; }
        void   setExternalVarSpace(const QStringList& ExternSpaceNames, double* ExternSpace);
        void enableIncSum();
        // other maintenance
        static void addConstant(const QString const_name, const double const_value);
private:
        enum ETokType {etNumber, etOperator, etVariable, etFunction, etLogical, etCompare, etStop, etUnknown, etDelimeter};
        enum EValueClasses {evcBHD, evcHoehe, evcAlter};
        struct ExtExecListItem {
            ETokType Type;
            double  Value;
            int     Index;
        };
        enum EDatatype {edtInfo, edtNumber, edtString, edtObject, edtVoid, edtObjVar, edtReference, edtObjectReference};
        bool m_catchExceptions;
        QString m_errorMsg;
 
        bool m_parsed;
        mutable bool m_strict;
        bool m_empty; // empty expression
        bool m_constExpression;
        QString m_tokString;
        QString m_expression;
        Expression::ExtExecListItem *m_execList;
        int m_execListSize; // size of buffer
        int m_execIndex;
        double m_varSpace[10];
        QStringList m_varList;
        QStringList m_externVarNames;
        double *m_externVarSpace;
        Expression::ETokType m_state;
        Expression::ETokType m_lastState;
        char *m_pos;
        char *m_expr;
        QString m_token;
        QString m_prepStr;
        int   m_tokCount;
        Expression::ETokType  next_token();
        void  atom();
        void  parse_levelL0();
        void  parse_levelL1();
        void  parse_level0();
        void  parse_level1();
        void  parse_level2();
        void  parse_level3();
        void  parse_level4();
        int  getFuncIndex(const QString& functionName);
        int  getVarIndex(const QString& variableName);
        inline double getModelVar(const int varIdx, ExpressionWrapper *object=nullptr) const ;
 
        // link to external model variable
        ExpressionWrapper *mModelObject;
 
        double getExternVar(const int Index) const;
        // inc-sum
        mutable double m_incSumVar;
        bool   m_incSumEnabled;
        double  udfPolygon(double Value, double* Stack, int ArgCount) const; 
        double  udfInList(double value, double* stack, int argCount) const; 
        double udfSigmoid(double Value, double sType, double p1, double p2) const; 
        double udfRandom(int type, double p1, double p2) const; 
 
        void checkBuffer(int Index);
        QMutex m_execMutex;
        // linearization
        inline double linearizedValue(const double x) const;
        inline double linearizedValue2d(const double x, const double y) const;
        int mLinearizeMode;
        QVector<double> mLinearized;
        double mLinearLow, mLinearHigh;
        double mLinearStep;
        double mLinearLowY, mLinearHighY;
        double mLinearStepY;
        int mLinearStepCountY;
        static bool mLinearizationAllowed;
};
 
#endif // LOGICEXPRESSION_H