/var/www/hormigaproject.com.ar/files/src/function/function.h

Go to the documentation of this file.

/*
# Hormiga - Software de cálculo programable.
#
# Copyright (C) 2008, 2009 Leonardo Román, Hugo J. Curti, Norma  Ercoli,
# Universidad Nacional del Centro de la Provincia de Buenos Aires
# (UNCPBA)
#
# Este programa es parte de Hormiga.
#
# Hormiga es software libre. Puede redistribuirlo y/o modificarlo
# bajo los términos de la Licencia Pública General de GNU según es
# publicada por la Free Software Foundation, versión 2. Vea el archivo
# COPIA (español, no oficial) o COPYING (inglés, oficial) en directorio
# raíz.
#
# Hormiga se distribuye con la esperanza de que sea útil, pero SIN
# NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL implícita o sin
# garantizar la CONVENIENCIA PARA UN PROPÓSITO PARTICULAR. Véase la
# Licencia Pública General de GNU para más detalles.
#
# Debería haber recibido una copia de la Licencia Pública General junto
# con Hormiga. Si no ha sido así, escriba a la Free Software
# Foundation, Inc., en 675 Mass Ave, Cambridge, MA 02139, EEUU.
# Añada también información sobre cómo contactar con usted mediante
# correo electrónico y postal.
#
# This file is part of Hormiga.
#
# Hormiga is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2
# as published by the Free Software Foundation; see the file COPYING
# in the top directory for details.
#
# Hormiga 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 Hormiga; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
# USA
*/

#ifndef FUNCTION_H
#define FUNCTION_H

#include "defines.h"

#include "oper/operand.h"
#include "statement/statement_interface.h"


class Function
{
public:
    virtual T_MAGNITUDE eval ( T_FUNCTION_ARGUMENTS *argv ) = 0 ;
    virtual T_STRING getName () = 0 ;
    virtual int paramsCount() = 0 ;
    virtual ~Function() {}
};

class UserFunction : public Function , public Typeable
{
public:
    UserFunction( T_STRING &symbol , T_FUNCTION_ARGUMENTS *argv ,
              VarValue* toRet , Statement *codeBlock ) ;
    T_MAGNITUDE eval ( T_FUNCTION_ARGUMENTS *argv ) ;
    int paramsCount() { return formalParams->count() ; }
    T_STRING getName () { return ( this->name ) ; }
protected:
    T_FUNCTION_ARGUMENTS *formalParams ;
    Statement *code ;
    VarValue* toRet ;
    T_STRING name ;
};

class FunctionInstanceIterator
{
public:
    const T_MAGNITUDE* first () ;

    const T_MAGNITUDE* next () ;

    const T_MAGNITUDE* getCurrent () ;

    int dimesionsCount () const { return this->dimensions ; }

    int iterationsCount () const ;

    FunctionInstanceIterator ( Function *f , T_FUNCTION_ARGUMENTS* realArgs ) ;
    ~FunctionInstanceIterator () ;
protected:
    void setup ( Function *f ,
                              T_FUNCTION_ARGUMENTS* internalArguments ,
                              T_MAGNITUDE* data ,
                              int dimensions ,
                              int currentDimension
                              ) ;
    FunctionInstanceIterator ( Function *f ,
                              T_FUNCTION_ARGUMENTS* internalArguments ,
                              T_MAGNITUDE* data ,
                              int dimensions ,
                              int currentDimension
                              ) ;

    bool hasNext () ;

    FunctionInstanceIterator *nextDimension ;
    int dimensions ;
        // count from 0:
    int localDimension ;
    T_MAGNITUDE* data ;

        // Original Sequence (don't delete it):
    Sequence *seq ;
        // local sequence current value (delete it):
    VarValue *currVal ;
        // Internal argv:
    T_FUNCTION_ARGUMENTS* args ;
        // Function for evaluate (don't delete it):
    Function *f ;
};


class FunctionInstance : public Operand
{
public:
    virtual T_STRING toString () const ;
    virtual T_MAGNITUDE getValue () const ;
    virtual T_STRING getSymbol () const ;
    virtual bool isConstantExpresion () const ;
    FunctionInstanceIterator* getIterator () const ;
    FunctionInstance ( Function *f , T_FUNCTION_ARGUMENTS *argv ) ;
    virtual ~FunctionInstance () ;
protected:
    T_MAGNITUDE eval ( T_FUNCTION_ARGUMENTS *argv ) const ;
    T_MAGNITUDE integrate ( T_FUNCTION_ARGUMENTS *reals ,
                            T_FUNCTION_ARGUMENTS *internals ,
                            T_INT_ARRAY *seqArgs ,
                            int actualArg = 0 ) const ;
    Function *f ;
    T_FUNCTION_ARGUMENTS *argv ;
};

#endif // FUNCTION_H