mathexpression.h

Go to the documentation of this file.

#ifndef mathexpression_h
#define mathexpression_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          10-12-1999
 RCS:           $Id$
________________________________________________________________________

-*/

#include "generalmod.h"
#include "bufstringset.h"


namespace Math
{

mExpClass(General) Expression
{
public:

    virtual double      getValue() const                = 0;

    virtual int         nrVariables() const;
    virtual const char* fullVariableExpression(int) const;
    virtual void        setVariableValue(int,double);

                        // recursive "out" or "this" excluded
    int nrUniqueVarNames() const
                        { return varnms_.size(); }
    const char* uniqueVarName( int idx ) const
                        { return varnms_.get(idx).buf(); }
    int indexOfUnVarName( const char* nm ) const
                        { return varnms_.indexOf( nm ); }
    int firstOccurVarName(const char*) const;

    enum VarType        { Variable, Constant, Recursive };
    VarType             getType(int varidx) const;
    int getConstIdx(int varidx) const;

    bool                isRecursive() const
                        { return isrecursive_; }

    virtual Expression* clone() const = 0;

    virtual             ~Expression();

    const char* type() const;
    void                dump( BufferString& str ) const { doDump(str,0); }

protected:

                        Expression(int nrinputs);

    int nrInputs() const { return inputs_.size(); }
    bool                setInput( int, Expression* );
    void                copyInput( Expression* target ) const;

    void                addIfOK(const char*);

    ObjectSet<TypeSet<int> > variableobj_;
    ObjectSet<TypeSet<int> > variablenr_;
    ObjectSet<Expression> inputs_;
    BufferStringSet     varnms_;
    bool                isrecursive_;

    friend class        ExpressionParser;

    void                doDump(BufferString&,int nrtabs) const;
    virtual void        dumpSpecifics(BufferString&,int nrtabs) const   {}

};


mExpClass(General) ExpressionParser
{
public:

                        ExpressionParser( const char* str=0,
                                          bool inputsareseries=true )
                            : inp_(str), abswarn_(false)
                            , inputsareseries_(inputsareseries) {}

    void                setInput( const char* s ) { inp_ = s; }
    Expression*         parse() const;

    static BufferString varNameOf(const char* fullvarnm,int* shift=0);
    static Expression::VarType varTypeOf(const char*);
    static int          constIdxOf(const char*);

    const char*         errMsg() const          { return errmsg_; }
    bool                foundOldAbs() const     { return abswarn_; }

protected:

    BufferString        inp_;
    const bool          inputsareseries_;
    mutable BufferString errmsg_;
    mutable bool        abswarn_;

    Expression*         parse(const char*) const;

    bool                findOuterParens(char*,int,Expression*&) const;
    bool                findOuterAbs(char*,int,Expression*&) const;
    bool                findQMarkOper(char*,int,Expression*&) const;
    bool                findAndOrOr(char*,int,Expression*&) const;
    bool                findInequality(char*,int,Expression*&) const;
    bool                findPlusAndMinus(char*,int,Expression*&) const;
    bool                findOtherOper(BufferString&,int,Expression*&) const;
    bool                findVariable(char*,int,Expression*&) const;
    bool                findMathFunction(BufferString&,int,
                                         Expression*&) const;
    bool                findStatsFunction(BufferString&,int,
                                          Expression*&) const;

};


mExpClass(General) ExpressionOperatorDesc
{
public:
                        ExpressionOperatorDesc( const char* s,
                                        const char* d, bool isop, int n )
                            : symbol_(s), desc_(d)
                            , isoperator_(isop), nrargs_(n)     {}

    const char*         symbol_; // can have spaces, e.g. "? :"
    const char*         desc_;
    bool                isoperator_; 
    int                 nrargs_; 
};


mExpClass(General) ExpressionOperatorDescGroup
{
public:

    BufferString                        name_;
    ObjectSet<ExpressionOperatorDesc>   opers_;

    static const ObjectSet<const ExpressionOperatorDescGroup>& supported();

};

} // namespace Math

#endif