Formula.h

Go to the documentation of this file.

/*
    liban - base function to do usefull things related to simulation and scientific work
    Copyright (C) 1999-2005 Stephane Magnenat <nct@ysagoon.com>
    Copyright (c) 2004-2005 Antoine Beyeler <antoine.beyeler@epfl.ch>
    Copyright (C) 2005 Laboratory of Intelligent Systems, EPFL, Lausanne
    See AUTHORS for details

    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __AN_FORMULA_H
#define __AN_FORMULA_H

#include <string>
#include <vector>
#include <stack>
#include <map>
#include <typeinfo>

namespace An
{
    class Formula
    {
    public:
        struct ParseResult
        {
            enum Result
            {
                SUCCESS = 0, 
                UNDEFINED_VARIABLE, 
                SYNTAX_ERROR 
            } result;
            size_t errorPos;
            
            ParseResult() { result = SUCCESS; errorPos = 0; }
            operator bool () const { return result == SUCCESS; }
        };
        
        typedef std::stack<double> ResultStack;
        
        struct BytecodeToken
        {
            virtual bool eval(ResultStack &stack) = 0;
            virtual const char *getType(void) { return typeid(*this).name(); }
        };
        
        typedef double (*UnaryFunctionPtr)(double);
        
        typedef std::vector<BytecodeToken *> Bytecode;
        typedef std::map<std::string, const double *> VariableMap;
        typedef std::map<std::string, UnaryFunctionPtr> FunctionMap;
        
    protected:
        std::string formulaText;
        VariableMap variableMap;
        FunctionMap functionMap;
        Bytecode bytecode;
        bool parsed;
        
    public:
        Formula(const std::string &formula, bool useStandardFunctions = true);
        virtual ~Formula();
        void setVariable(const std::string &name, const double &value);
        void addUnaryFunction(const std::string &name, UnaryFunctionPtr funcPtr);
        ParseResult parse(void);
        double eval(void);
        
    protected:
        // standard functions
        static double sqr(double v) { return v*v; }
        static double sgn(double v) { return v > 0.0 ? 1.0 : (v < 0.0 ? -1.0 : 0.0); }
    };
}

#endif

---