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

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
*/

#include "function.h"

UserFunction::UserFunction( T_STRING &symbol , T_FUNCTION_ARGUMENTS *argv ,
                    VarValue* toRet , Statement *codeBlock )
        : Typeable ( toRet->getType () )
{
    this->formalParams = argv ;
    this->code = codeBlock ;
    this->toRet = toRet ;
    this->name = symbol ;
}

T_MAGNITUDE UserFunction::eval( T_FUNCTION_ARGUMENTS *argv )
{
    /* First. We need to setup arguments relationship */
    int lastArg = formalParams->count() ;
    for ( int i = 0 ; i < lastArg ; i++ )
    {
        VarValueProxy *fp = (VarValueProxy*) formalParams->at( i ) ;
        fp->setProxiedOperand( argv->at( i ) ) ;
    }
    toRet->setValue( 0.0 ) ;
    /* Ok ... now we are ready to run ! */
    this->code->exec() ;
    return toRet->getValue() ;
}


T_STRING FunctionInstance::toString () const
{
    QString args = "" ;
    for ( int i = 0; i < this->argv->count() ; i++ )
    {
        if ( i != 0 )
            args += ", " ;
        args += this->argv->at( i )->toString() ;
    }
    return ( QString ("%1 ( %2 )")
             .arg ( this->f->getName() )
             .arg ( args ) ) ;
}

T_STRING FunctionInstance::getSymbol () const
{
    return ( f->getName() ) ;
}

bool FunctionInstance::isConstantExpresion () const
{
    return ( false ) ;
}

FunctionInstanceIterator* FunctionInstance::getIterator () const
{
    return new FunctionInstanceIterator ( this->f , this->argv );
}

T_MAGNITUDE FunctionInstance::getValue () const
{
    /* We need to known if you want to 'evaluate' or 'integrate' this function*/
    bool integrate = FALSE ;
    T_FUNCTION_ARGUMENTS internalArgs ;
    T_INT_ARRAY seqArgs ;
    for ( int i = 0; i < this->argv->count() ; i++ )
    {
        VarValueProxy *o = (VarValueProxy*) argv->at( i ) ;
        if ( o->getProxiedOperand()->isSequence() )
        {
            integrate = true ;
        /* Crear un arreglo auxiliar e ir cargandole cada uno de los 'parametros'.
           En caso de encontrar un 'sequence' reemplazarlo en el arr.aux por un
           VarValueProxy. Estos parametros reemplazados junto con las secuencias
           asociadas deben ademas agregarse en otro arreglo auxiliar el cual
           sera usado en un algoritmo recursivo que realizara la integracion.
           */
            seqArgs.append( i ) ;
            VarValueProxy *vp = new VarValueProxy("Seq Value" , NULL , false ) ;
            //vp->setValue( ((Sequence*) o->getProxiedOperand())->getFirst () ) ;
            internalArgs.append( vp ) ;
        }
        else
        {
            /* First... PRE-calc and cache parameters */
            o->resetInternalValue() ;
            o->setValue( o->getValue() ) ;
            internalArgs.append( o ) ;
        }
    }
    if ( integrate )
    {
        T_MAGNITUDE toRet = this->integrate( this->argv , &internalArgs ,
                                             &seqArgs , 0 ) ;
        for ( int i = seqArgs.count() - 1 ; i >= 0 ; i-- )
        {   /* delete only ValueProxys created before */
            delete internalArgs.takeAt( seqArgs.at( i ) ) ;
        }
        return ( toRet ) ;
    }
    else
        return ( this->eval( this->argv ) ) ;
}

T_MAGNITUDE FunctionInstance::integrate ( T_FUNCTION_ARGUMENTS *reals ,
                                          T_FUNCTION_ARGUMENTS *internals ,
                                          T_INT_ARRAY *seqArgs ,
                                          int actualArg ) const
{
    int pn = seqArgs->at( actualArg ) ; /* Param Number */
    Sequence *s = (Sequence*)( (VarValueProxy*) reals->at( pn ) )
                                        ->getProxiedOperand() ;
    VarValueProxy *v = (VarValueProxy*) internals->at( pn ) ;
    T_MAGNITUDE total = 0 ;
    // Here we will cache the last result
    T_MAGNITUDE prev = 0 ;
    for ( T_MAGNITUDE i = s->getFirst() ; i <= s->getLast() ; i += s->getStep() )
    {
        v->setValue( i ) ;
        T_MAGNITUDE a = 0 ;
        if ( actualArg != ( seqArgs->count() - 1 ) )
        {
            a = integrate( reals, internals , seqArgs ,
                                       actualArg + 1 ) ;
        }
        else
        {
            a = this->eval ( internals ) ;
        }
        if ( i != s->getFirst() )
        {   // Interpolated result:
            total += ( a + prev ) * s->getStep() / 2 ;
        }
        prev = a ;
    }
    return ( total ) ;
}

T_MAGNITUDE FunctionInstance::eval ( T_FUNCTION_ARGUMENTS *argv ) const
{
    return ( this->f->eval( argv ) ) ;
}

FunctionInstance::FunctionInstance ( Function *f , T_FUNCTION_ARGUMENTS *argv )
{
    this->f = f ;
    this->argv = argv ;
}

FunctionInstance::~FunctionInstance ()
{
    for ( int i = 0; i < this->argv->count() ; i++ )
    {
        Operand *o = this->argv->at( i ) ;
        if ( ! o->isShareable() )
            delete o ;
    }
    delete this->argv ;
}


const T_MAGNITUDE* FunctionInstanceIterator::first()
{
    if ( this->seq != NULL ) {
        this->data[localDimension] = this->seq->getFirst() ;
        this->currVal->setValue( this->data[localDimension] ) ;
        if ( this->nextDimension != NULL ) this->nextDimension->first() ;
    }
    if ( this->localDimension == 0 ) // I'm the master ?
        this->data[dimensions] = this->f->eval( this->args ) ;
    return this->data ;
}

bool FunctionInstanceIterator::hasNext()
{
    if ( this->seq == NULL ) return false ;
    if ( this->seq->getLast() >= ( this->data[localDimension] + this->seq->getStep() ) )
        return true ;
    if ( this->nextDimension != NULL )
        return this->nextDimension->hasNext() ;
    return false ;
}

const T_MAGNITUDE* FunctionInstanceIterator::next()
{
    if ( (this->nextDimension != NULL) && (this->nextDimension->hasNext()) ) {
        this->nextDimension->next() ;
    } else if ( this->hasNext() ) {
        // Reset next dimensions and advance this one.
        if ( this->nextDimension != NULL ) this->nextDimension->first() ;
        this->data[localDimension] += this->seq->getStep() ;
    } else return NULL ;
    // Allways refresh the value of VarValue, in case the function has been modified it.
    this->currVal->setValue( this->data[localDimension] ) ;
    if ( this->localDimension == 0 ) // I'm the master ?
        this->data[this->dimensions] = f->eval( this->args ) ;
    return this->data ;
}

const T_MAGNITUDE* FunctionInstanceIterator::getCurrent()
{
    return this->data ;
}

#include <math.h>
int FunctionInstanceIterator::iterationsCount () const
{
    int count = 0 ;
    if ( this->seq != NULL ) {
        for ( T_MAGNITUDE v = seq->getFirst() ; v <= seq->getLast() ; v+= seq->getStep() )
            count++ ;
    }
    if ( this->nextDimension != NULL )
        count *= this->nextDimension->iterationsCount() ;
    return count ;
}

FunctionInstanceIterator::FunctionInstanceIterator( Function *f , T_FUNCTION_ARGUMENTS* realArgs )
{
    this->args = new T_FUNCTION_ARGUMENTS( *realArgs ) ;
    this->seq = NULL ;
    int dim = 0 ;   // dimensions count
    for ( int i = 0; (i < this->args->count()) && !this->seq  ; i++ )
    {
        VarValueProxy *o = (VarValueProxy*) this->args->at( i ) ;
        if ( o->getProxiedOperand()->isSequence() ) {
            dim++ ;
        } else {
            // Pre-calcular y cachear los valores de los paramentros que no sean secuencias
            o->resetInternalValue() ;
            o->setValue( o->getValue() ) ;
        }
    }
    this->data = new T_MAGNITUDE[dim+1] ;
    this->setup( f, this->args, this->data, dim, 0 ) ;
}

FunctionInstanceIterator::FunctionInstanceIterator( Function *f ,
                              T_FUNCTION_ARGUMENTS* internalArguments ,
                              T_MAGNITUDE* data ,
                              int dimensions ,
                              int currentDimension
                              )
{
    this->setup( f, internalArguments, data, dimensions, currentDimension ) ;
}

void FunctionInstanceIterator::setup( Function *f ,
                              T_FUNCTION_ARGUMENTS* internalArguments ,
                              T_MAGNITUDE* data ,
                              int dimensions ,
                              int currentDimension
                              )
{
    this->nextDimension = NULL ;
    this->f = f ;
    this->args = internalArguments ;
    this->data = data ;
    this->dimensions = dimensions ;
    this->localDimension = currentDimension ;

    this->seq = NULL ;
    for ( int i = 0; (i < internalArguments->count()) && !this->seq  ; i++ )
    {   /* Find for the first 'Sequence', own it, and replace it in the vector
           by a VarValue */
        VarValueProxy *o = (VarValueProxy*) internalArguments->at( i ) ;
        if ( o->getProxiedOperand()->isSequence() ) {
            this->seq = (Sequence*) o->getProxiedOperand() ;
            data[currentDimension] = this->seq->getFirst() ;
            this->currVal = new VarValue() ; //("Seq Value" , NULL , false ) ;
            this->currVal->setValue( data[currentDimension] ) ;
            internalArguments->replace( i , this->currVal ) ;
            break ;
        }
    }
    currentDimension++ ;
    if ( currentDimension < dimensions ) {
        this->nextDimension = new FunctionInstanceIterator( f , internalArguments ,
                                                            data , dimensions ,
                                                            currentDimension ) ;
    }
}

FunctionInstanceIterator::~FunctionInstanceIterator()
{
    if ( this->nextDimension ) delete this->nextDimension ;
    // Only in the main Iterator:
    if ( this->localDimension == 0 ) {
        delete this->args ;
        delete[] this->data ;
    }
    if ( this->seq != NULL ) {
        delete this->currVal ;
    }
}