Generated/html/mathformula_8h_source.html

#pragma once


/*+

________________________________________________________________________


 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt

 Author:        Bert

 Date:          Apr 2014

 RCS:           $Id$

________________________________________________________________________


-*/


#include "generalmod.h"

#include "ranges.h"

#include "typeset.h"

#include "threadlock.h"


class UnitOfMeasure;


namespace Math

{


class SpecVarSet;

class Expression;


mExpClass(General) Formula

{

public:


                        Formula(bool inputsareseries=true,const char* txt=0);

                        Formula(bool inputsareseries,const SpecVarSet&,

                                const char* txt=0);

                        Formula(const Formula&);

                        ~Formula();

    Formula&            operator =(const Formula&);


                // 0. Specify the formula text. Will construct a new Expression


    void                setText(const char*);


                // 1. Things known after construction or setText()


    bool                isOK() const            { return expr_; }

    bool                isBad() const           { return !expr_

                                                      && !text_.isEmpty(); }

    const char*         errMsg() const          { return errmsg_; }


    const char*         text() const            { return text_; }

    int                 nrInputs() const        { return inps_.size(); }

    const char*         variableName( int iinp ) const

                                                { return inps_[iinp].varname_; }

    bool                isConst( int iinp ) const

                                                { return inps_[iinp].isConst();}

    bool                isSpec( int iinp ) const

                                                { return inps_[iinp].isSpec(); }

    int                 specIdx(int) const;

    const TypeSet<int>& getShifts( int iinp ) const

                                                { return inps_[iinp].shifts_; }

    Interval<int>       shiftRange( int iinp ) const

                                                { return inps_[iinp].shftRg(); }

    bool                isRecursive() const     { return maxRecShift() > 0; }

    int                 maxRecShift() const     { return recstartvals_.size(); }


                // 2. Things to set before calculation or store


    void                setInputDef(int,const char*);

    void                setInputUnit(int,const UnitOfMeasure*);

    void                setOutputUnit( const UnitOfMeasure* uom )

                                                { outputunit_ = uom; }

    TypeSet<double>&    recStartVals()          { return recstartvals_; }

    void                clearInputDefs();


                // 3. Things you have set yourself or that were retrieved


    const UnitOfMeasure* outputUnit() const     { return outputunit_; }

    const char*         inputDef( int iinp ) const

                                                { return inps_[iinp].inpdef_; }

    const UnitOfMeasure* inputUnit( int iinp ) const

                                                { return inps_[iinp].unit_; }

    double              getConstVal(int) const;


                // 4. To get an output value


    int                 nrValues2Provide() const;

    void                startNewSeries() const; // resets recursive values

    float               getValue(const float*,bool internal_units=true) const;

    double              getValue(const double*,bool internal_units=true) const;


                // 5. store/retrieve to/from IOPar


    void                fillPar(IOPar&) const;

    void                usePar(const IOPar&);


    const Expression*   expression() const      { return expr_; };

    const SpecVarSet&   specVars() const        { return *specvars_; }

    bool                inputsAreSeries() const { return inputsareseries_; }

    int                 nrConsts() const;

    const char*         userDispText() const;

    int                 nrExternalInputs() const;


    static const char*  sKeyExpression()        { return "Expression"; }

    static const char*  sKeyRecStartVals()      { return "Recursion start"; }

    static const char*  sKeyFileType()          { return "Math Formula"; }


protected:


    class InpDef

    {

    public:


        enum Type               { Var, Const, Spec };


                                InpDef( const char* nm, Type t )

                                    : varname_(nm), unit_(0), type_(t)  {}

        bool                    operator==( const InpDef& id ) const

                                { return varname_ == id.varname_; }


        BufferString            varname_;       // from Expression

        Type                    type_;          // from Expression

        TypeSet<int>            shifts_;        // from Expression

        BufferString            inpdef_;        // filled by class user

        const UnitOfMeasure*    unit_;          // filled by class user


        Interval<int>           shftRg() const;

        bool                    isConst() const { return type_ == Const; }

        bool                    isSpec() const  { return type_ == Spec; }


    };


    BufferString        text_;

    TypeSet<InpDef>     inps_;

    const UnitOfMeasure* outputunit_;

    TypeSet<double>     recstartvals_;

    const SpecVarSet*   specvars_;

    const bool          inputsareseries_;


    Expression*         expr_;


                        // length: expr_->nrVariables()

    TypeSet<int>        inpidxs_;

    TypeSet<int>        recshifts_;

    TypeSet<int>        validxs_;


    mutable TypeSet<double>     prevvals_;

    mutable BufferString        errmsg_;

    mutable Threads::Lock       formlock_;


    int                 varNameIdx(const char* varnm) const;

    void                addShift(int,int,int&,TypeSet< TypeSet<int> >&);


};


} // namespace Math