evaluator_impl.h

Go to the documentation of this file.

/* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/libraries/libmbutil/evaluator_impl.h,v 1.4 2017/01/12 14:44:04 masarati Exp $ */
/*
 * MBDyn (C) is a multibody analysis code.
 * http://www.mbdyn.org
 *
 * Copyright (C) 1996-2017
 *
 * Pierangelo Masarati  <masarati@aero.polimi.it>
 * Paolo Mantegazza     <mantegazza@aero.polimi.it>
 *
 * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
 * via La Masa, 34 - 20156 Milano, Italy
 * http://www.aero.polimi.it
 *
 * Changing this copyright notice is forbidden.
 *
 * 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 (version 2 of the License).
 *
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * With the contribution of Ankit Aggarwal <ankit.ankit.aggarwal@gmail.com>
 * during Google Summer of Code 2015
 */

#ifndef EVALUATOR_IMPL_H
#define EVALUATOR_IMPL_H

#include <iostream>
#include <sstream>
#include <cmath>
#include <limits>

// "evaluator.h" must be explicitly included

// for storing constant values like "1","1.23"
class EE_Value : public ExpressionElement {
private:
        TypedValue m_Val;

public:
        EE_Value(TypedValue Val) : m_Val(Val) { m_Val.SetConst(true); };
        // nothing to destroy
        ~EE_Value(void) {};

        TypedValue
        Eval(void) const
        {
                return m_Val;
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << m_Val;
        };
};

// for storing non const variable like "a", "b"
// FIXME: probably needs to know about its namespace
class EE_Var : public ExpressionElement {
private:
        NamedValue *m_Var;
        // NOTE: probably the string would suffice, but just in case...
        MathParser::NameSpace *m_ns;

public:
        EE_Var(NamedValue *var, MathParser::NameSpace *ns = 0) : m_Var(var), m_ns(ns) {};
        // nothing to destroy (Var belongs to the symbol table)
        virtual ~EE_Var(void) {};

        virtual TypedValue
        Eval(void) const
        {
                // NOTE: this should not be const,
                // otherwise it would have been turned into a EE_Value
                return m_Var->GetVal();
        };

        virtual std::ostream&
        Output(std::ostream& out) const
        {
                if (m_ns) {
                        out << m_ns->sGetName() << "::";
                }

                return out << m_Var->GetName();
        };
};

class EE_Plus : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Plus(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Plus(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                // FIXME: check integer overflow?
                return m_pEE1->Eval() + m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " + ", m_pEE2->Output(out) << ")";
        };
};

class EE_Minus : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Minus(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Minus(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                // FIXME: check integer overflow?
                return m_pEE1->Eval() - m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " - ", m_pEE2->Output(out) << ")";
        };
};

class EE_Modulus : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

#if 0 // TODO: check correctness whenever possible
        bool
        Check_int(const TypedValue& value)
        {
                switch (value.GetType()) {
                case TypedValue::VAR_BOOL:
                case TypedValue::VAR_INT:
                        if (value.GetInt() == 0) {
                                return false;
                        }
                        break;

                default:
                        return false;
                }
        };
#endif

public:
        EE_Modulus(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Modulus(void) { delete m_pEE1; delete m_pEE2; };

#if 0 // TODO: check correctness whenever possible
        bool
        Check(void) const
        {
                if (dynamic_cast<EE_Value *>(m_pEE2)) {
                        return Check_int(m_pEE2->Eval());
                }
                return true;
        };
#endif

        TypedValue
        Eval(void) const
        {
                // FIXME: the check on types should be done while parsing, if possible...
                TypedValue a = m_pEE2->Eval();
                if (a.GetType() == TypedValue::VAR_INT || a.GetType() == TypedValue::VAR_BOOL) {
                        ASSERT(a.GetInt() != 0);
                        return m_pEE1->Eval() % a;
                }
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " % ", m_pEE2->Output(out) << ")";
        };
};

class EE_Multiply : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Multiply(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Multiply(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() * m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " * ", m_pEE2->Output(out) << ")";
        };
};

class EE_Divide : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Divide(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Divide(void) { delete m_pEE1; delete m_pEE2; };
        // need to take care of zero denominator

        TypedValue
        Eval(void) const
        {
                TypedValue den = m_pEE2->Eval();
                if (den.GetType() == TypedValue::VAR_BOOL) {
                        ASSERT(den.GetBool() != 0);

                } else if (den.GetType() == TypedValue::VAR_INT) {
                        ASSERT(den.GetInt() != 0);

                } else if (den.GetType() == TypedValue::VAR_REAL) {
                        Real value = den.GetReal();
                        if (std::abs(value) < std::numeric_limits<double>::epsilon()) {
                                // need to throw exception over here
                                std::cout << "denominator cannot be zero" << std::endl;
                        }
                }

                return m_pEE1->Eval() / den;
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " / ", m_pEE2->Output(out) << ")";
        };
};

class EE_Unary_minus : public ExpressionElement {
private:
        ExpressionElement *m_pEE1;

public:
        EE_Unary_minus(ExpressionElement *pEE1) : m_pEE1(pEE1) {};
        ~EE_Unary_minus(void) { delete m_pEE1; };

        TypedValue
        Eval(void) const
        {
                return -m_pEE1->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(-", m_pEE1->Output(out) << ")";
        };
};

class EE_AND : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_AND(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_AND(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() && m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " && ", m_pEE2->Output(out) << ")";
        };
};

class EE_OR : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_OR(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_OR(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() || m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " || ", m_pEE2->Output(out) << ")";
        };
};

class EE_NOT : public ExpressionElement {
private:
        ExpressionElement *m_pEE1;

public:
        EE_NOT(ExpressionElement *pEE1) : m_pEE1(pEE1) {};
        ~EE_NOT(void) { delete m_pEE1; };

        TypedValue
        Eval(void) const
        {
                return  !(m_pEE1->Eval());
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(!", m_pEE1->Output(out) << ")";
        };
};

// need to implement ~= as overloaded operator in mathp.cc
class EE_XOR : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_XOR(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_XOR(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                TypedValue v1 = m_pEE1->Eval();
                TypedValue v2 = m_pEE2->Eval();
                return ((!(v1 && v2)) && (v1 || v2));
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " ~| ", m_pEE2->Output(out) << ")";
        };
};

class EE_Greater : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Greater(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Greater(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() > m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " > ", m_pEE2->Output(out) << ")";
        };
};

class EE_Greater_Equal : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Greater_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Greater_Equal(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() >= m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " >= ", m_pEE2->Output(out) << ")";
        };
};

class EE_Lesser : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Lesser(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Lesser(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() < m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " < ", m_pEE2->Output(out) << ")";
        };
};

class EE_Lesser_Equal : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Lesser_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Lesser_Equal(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return m_pEE1->Eval() <= m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " <= ", m_pEE2->Output(out) << ")";
        };
};

class EE_Equal_Equal : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Equal_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Equal_Equal(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return (m_pEE1->Eval()) == (m_pEE2->Eval());
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " == ", m_pEE2->Output(out) << ")";
        };
};

class EE_Not_Equal : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Not_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Not_Equal(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                return (m_pEE1->Eval()) != (m_pEE2->Eval());
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " != ", m_pEE2->Output(out) << ")";
        };
};

class EE_Power : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_Power(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_Power(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                TypedValue a = m_pEE1->Eval();
                TypedValue b = m_pEE2->Eval();
                if (a.GetType() == TypedValue::VAR_STRING || b.GetType() == TypedValue::VAR_STRING) {
                        silent_cerr(" power undefined between string " << a << " and " << b << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);

                } else if ((a.GetType() == TypedValue::VAR_INT && b.GetType() == TypedValue::VAR_INT)
                        || (a.GetType() == TypedValue::VAR_BOOL && b.GetType() == TypedValue::VAR_BOOL))
                {
                        Real value = std::pow(a.GetInt(), b.GetInt());
                        if (Real(Int(value)) != value) {
                                silent_cerr(" power(" << a.GetInt() << ", " << b.GetInt() << ") overflows (use explicit/implicit cast?)" << std::endl);
                                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                        }
                        return value;

                } else {
                        return std::pow(a.GetReal(), b.GetReal());
                }
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " ^ ", m_pEE2->Output(out) << ")";
        };
};

#if 1
// FIXME: needs review
// for storing value that is which is evaluated first then assigned

class EE_Assign : public ExpressionElement {
private:
        mutable Var *m_Var;
        MathParser::NameSpace *m_ns;
        const ExpressionElement *m_pEE;

public:
        EE_Assign(Var *var, MathParser::NameSpace *ns, ExpressionElement *pEE) : m_Var(var), m_ns(ns), m_pEE(pEE) {};
        ~EE_Assign(void) { delete m_pEE; };

        TypedValue
        Eval(void) const
        {
                TypedValue v(m_pEE->Eval());
                m_Var->SetVal(v);
                return v;
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                out << "(";
                if (m_ns) {
                        out << m_ns->sGetName() << "::";
                }

                return out << m_Var->GetName() << " = ", m_pEE->Output(out) << ")";
        };
};

/* the variable is pre-declared */
class EE_DeclareAssign : public ExpressionElement {
private:
        mutable Var *m_Var;
        MathParser::NameSpace *m_ns;
        const ExpressionElement *m_pEE;
        mutable bool m_bEvaluated;

public:
        EE_DeclareAssign(Var *var, MathParser::NameSpace *ns, ExpressionElement *pEE = 0) : m_Var(var), m_ns(ns), m_pEE(pEE), m_bEvaluated(false) {};
        ~EE_DeclareAssign(void) { if (m_pEE) { delete m_pEE; } };

        TypedValue
        Eval(void) const
        {
                if (m_bEvaluated) {
                        silent_cerr(" variable " << m_Var->GetName() << " already declared" << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                m_bEvaluated = true;

                if (m_pEE) {
                        TypedValue v(m_pEE->Eval());
                        m_Var->SetVal(v);
                        return v;
                }

                return TypedValue(0, true);
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                out << "(";
                if (m_Var->Const()) {
                        out << "const ";
                }

                out << m_Var->GetTypeName() << " ";
                
                if (m_ns) {
                        out << m_ns->sGetName() << "::";
                }

                return out << m_Var->GetName() << " = ", m_pEE->Output(out) << ")";
        };
};
#endif

// for storing like <stmt>;<stmt>
class EE_StmtList : public ExpressionElement {
private:
        ExpressionElement *m_pEE1, *m_pEE2;

public:
        EE_StmtList(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
        ~EE_StmtList(void) { delete m_pEE1; delete m_pEE2; };

        TypedValue
        Eval(void) const
        {
                // FIXME: the first expression must exist
                ASSERT(m_pEE1 != 0);

                if (m_pEE1 != 0) {
                        m_pEE1->Eval();
                }

                return m_pEE2->Eval();
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                return out << "(", m_pEE1->Output(out) << " ; ", m_pEE2->Output(out) << ")";
        };
};

class EE_Func : public ExpressionElement {
private:
        // pointer to MathParser only needed for exception handling
        MathParser *m_p;
        MathParser::MathFunc_t *m_f;

public:
        EE_Func(MathParser *p, MathParser::MathFunc_t *f)
        : m_p(p), m_f(f)
        {
        };

        ~EE_Func(void)
        {
                for (unsigned i = 0; i < m_f->args.size(); ++i) {
                        const ExpressionElement *ee = m_f->args[i]->GetExpr();
                        if (ee) {
                                delete ee;
                        }
                }
                delete m_f;
        };

        TypedValue
        Eval(void) const
        {
                // sure args[0] does not need to be evaluated: it's the return value
                for (unsigned i = 1; i < m_f->args.size(); i++) {
                        m_f->args[i]->Eval();
                }

                if (m_f->t != 0) {
                        if (m_f->t(m_f->args)) {
                                DEBUGCERR("error in function "
                                        << m_f->ns->sGetName() << "::" << m_f->fname
                                        << " " "(msg: " << m_f->errmsg << ")"
                                        << " in EE_Func()" << std::endl);
                                throw MathParser::ErrGeneric(m_p, MBDYN_EXCEPT_ARGS,
                                        m_f->fname + ": error " + m_f->errmsg);
                        }
                }

                TypedValue val = m_f->ns->EvalFunc(m_f);

                return val;
        };

        std::ostream&
        Output(std::ostream& out) const
        {
                if (m_f->ns) {
                        out << m_f->ns->sGetName() << "::";
                }

                out << m_f->fname << "(";
                const ExpressionElement *ee = m_f->args[1]->GetExpr();
                if (ee != 0) {
                        ee->Output(out);
                        for (unsigned i = 2; i < m_f->args.size(); ++i) {
                                ee = m_f->args[i]->GetExpr();
                                if (ee == 0) {
                                        break;
                                }
                                out << ", ", ee->Output(out);
                        }
                }
                out << ")";

                return out;
        };
};

// unary operator construction helper with optimization
template <class T>
ExpressionElement *
EECreate(ExpressionElement *e1)
{
        ExpressionElement *out = new T(e1);
        if (ExpressionElement::IsFlag(ExpressionElement::EE_CONSTIFY)) {
                if (dynamic_cast<EE_Value *>(e1)) {
                        ExpressionElement *tmp = new EE_Value(out->Eval());
                        delete out;
                        return tmp;
                }
        }
        return out;
}

// binary operator construction helper with optimization
template <class T>
ExpressionElement *
EECreate(ExpressionElement *e1, ExpressionElement *e2)
{
        ExpressionElement *out = new T(e1, e2);
        if (ExpressionElement::IsFlag(ExpressionElement::EE_CONSTIFY)) {
                if (dynamic_cast<EE_Value *>(e1) && dynamic_cast<EE_Value *>(e2)) {
                        ExpressionElement *tmp = new EE_Value(out->Eval());
                        delete out;
                        return tmp;
                }
        }
        return out;
}

// ternary operator construction helper with optimization
template <class T>
ExpressionElement *
EECreate(ExpressionElement *e1, ExpressionElement *e2, ExpressionElement *e3)
{
        ExpressionElement *out = new T(e1, e2, e3);
        if (ExpressionElement::IsFlag(ExpressionElement::EE_CONSTIFY)) {
                if (dynamic_cast<EE_Value *>(e1) && dynamic_cast<EE_Value *>(e2) && dynamic_cast<EE_Value *>(e3)) {
                        ExpressionElement *tmp = new EE_Value(out->Eval());
                        delete out;
                        return tmp;
                }
        }
        return out;
}

#endif // EVALUATOR_IMPL_H