moMathFunction.h

Ir a la documentación de este archivo.

/*******************************************************************************

                                moMathFunction.h

  ****************************************************************************
  *                                                                          *
  *   This source 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 code 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.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  \copyright copyright(C) 2006 Fabricio Costa

  \author Fabricio Costa
  \author Andrés Colubri

*******************************************************************************/

#ifndef __MO_MATH_FUNCTION_H__
#define __MO_MATH_FUNCTION_H__

#include "moTypes.h"
#include "moArray.h"
#include "moAbstract.h"
#include "moMath.h"

class moParam;
class moConfig;
class moMoldeoObject;
class moInlet;

typedef void moParser;

moDeclareExportedDynamicArray( MOuint, moIntArray );
moDeclareExportedDynamicArray( bool, moBoolArray );
moDeclareExportedDynamicArray( float, moFloatArray );


class moMathVariable : public moAbstract
{
public:
    moMathVariable();
    moMathVariable(const char* p_name, double p_value0 = 0.0);
    moMathVariable( moParam* p_Param  );
    moMathVariable( moInlet* p_Inlet  );

    void SetParam( moParam* p_Param );
    void SetInlet( moInlet* p_Inlet );

    void SetName(moText& p_name) { m_name = p_name; }
    moText& GetName() { return m_name; }

    void SetValue(double p_value) { m_value = p_value; }
    double GetValue();




    double* GetValuePointer();

private:
    moText m_name;
    double m_value;

    moParam*    m_pParam;

    moInlet*    m_pInlet;
};

typedef moMathVariable* moMathVariablePtr;
moDeclareExportedDynamicArray( moMathVariablePtr, moMathVariableArray );


class LIBMOLDEO_API moMathFunction : public moAbstract
{
public:
    moMathFunction();
    virtual ~moMathFunction();

    virtual MOboolean Init(const moText& p_Expression, moMoldeoObject* p_pMOB = NULL );
    virtual MOboolean Finish();

    virtual void SetExpression(const moText& p_Expression) { m_Expression = p_Expression; }
    virtual moText& GetExpression() { return m_Expression; }
    virtual void SetParameters(double s, ...);

    virtual double Eval();

    double LastEval();

    virtual double Eval(double x, ...);

    virtual double DEval(int n, ...);

    MOuint GetParameterCount();
    moText& GetParameterName(int i);
    double GetParameterValue(int i);

    MOuint GetVariableCount();
    moText& GetVariableName(int i);
    double GetVariableValue(int i);

    double operator () (double x, ...);
protected:
    moText m_EmptyName;
    moText m_Expression;
    moMathVariableArray m_Parameters;
    moMathVariableArray m_Variables;

    double m_LastEval;

    virtual void OnParamUpdate() = 0;
    virtual double OnFuncEval() = 0;
    virtual double OnDerivEval(int n) = 0;

    virtual void BuildParamList() = 0;
    virtual void BuildVarList() = 0;

    moConfig*   m_pConfig;
    moMoldeoObject* m_pMOB;
};

typedef moMathFunction* MathFunctionPtr;
moDeclareExportedDynamicArray( MathFunctionPtr, moMathFunctionArray );

/*******************************************************************************
                     Algunas funciones matemáticas pre-defindas
*******************************************************************************/

class LIBMOLDEO_API moCubicInterpolant : public moMathFunction
{
public:
    MOboolean Init(moText& p_Expression);
private:
    double C1, C2, C3, C4;

    void OnParamUpdate();
    double OnFuncEval();
    double OnDerivEval(int n);

    void BuildParamList();
    void BuildVarList();
};

class LIBMOLDEO_API moTautInterpolant : public moMathFunction
{
public:
    MOboolean Init(moText& p_Expression);
private:
    double A, B, C, D;
    double delta, alpha, zeta, knot;
    double delta_inv, one_minus_knot_inv;
    double alpha2, knot2, one_minus_knot_inv2;

    double PhiFunc1(double u);
    double DPhiFunc1(double u);

    double PhiFunc2(double u);
    double DPhiFunc2(double u);

    void OnParamUpdate();
    double OnFuncEval();
    double OnDerivEval(int n);

    void BuildParamList();
    void BuildVarList();
};

moMathFunction* BuiltInMathFunctionFactory(const moText& p_expr);

class LIBMOLDEO_API moMathVariableFactory : public moAbstract
{
public:
    moMathVariableFactory(moMathVariableArray* p_pParArray, moMathVariableArray* p_pVarArray)
    {
        m_pParArray = p_pParArray;
        m_pVarArray = p_pVarArray;
    }

    double* CreateNewVariable(const char *p_pNewName)
    {
        moMathVariable* pvar = new moMathVariable(p_pNewName, 0.0);

        if (p_pNewName != NULL) {
            if (p_pNewName[0] == '_') m_pParArray->Add(pvar); // Agregando parámetro.
            else m_pVarArray->Add(pvar);                      // Agregando variable.
        }
        return pvar->GetValuePointer();
    }
private:
    moMathVariableArray* m_pParArray;
    moMathVariableArray* m_pVarArray;
};

double* AddParserVariableFunction(const char *p_pVarName, void *p_pUserData);

class LIBMOLDEO_API moParserFunction : public moMathFunction
{
public:

    moParserFunction();


    virtual MOboolean Init(const moText& p_Expression, moMoldeoObject* p_pMOB = NULL );
    MOboolean Finish();
protected:

    double x;

    moParser*   m_pParser;

    void AddMathFunctions();
    void AddMathConstants();
    MOboolean CheckVariables();

    void OnParamUpdate() {}
    double OnFuncEval();
    double OnDerivEval(int n) { return n; }

    void BuildParamList() {}
    void BuildVarList() {}
};



#endif