[z.facultad/75.68/celdas.git] / trunk / src / sistemaautonomo.h

#ifndef __SISTEMAAUTONOMO__
#define __SISTEMAAUTONOMO__

#include "indicemagico.h"

// DEFINICIONES:
// ------------
//
//      ENTORNO:                        Variables que definen el entorno.
//  CONDICION                   va=a AND vb=b AND vc=c.
//      TEORIA:                         Se cumple condicion_inicial y ejecuto funcion F, entonces se cumplira condicion_final.
//      SISTEMA AUTONOMO:       Tiene un ENTORNO y una cantidad de TEORIAS.
//      CICLO:                          Son los pasos de:
//                                                      * Tomar los valores el entorno.
//                                                      * Decidir una condicion que deberia cumplir el entorno.
//                                                      * Planificar (PLAN) una serie de acciones (PASOS) para alcanzar la condicion deseada.
//                                                      * Ejecutar el plan, verificando en cada paso que se vayan cumpliendo las teorias intermedias.
//      PLAN:
//      PASO:

class CEntorno ;

typedef double t_dato ;
#define t_fnc(name)             double (*name)(CEntorno&)


#define INFINITO        9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long



// ------------------------------------------
// Parametros de configuracion de SA


// [Ejecutador]

// Precision en la comparacion de atributos.
// Poner en 0 si se quiere hacer la comparacion exacta.
#define PRECISION                                                               0.50000

// Cuando se ejecuta un plan, se espera que al termina el ultimo paso se hallan alcanzado las condiciones finales.
// Es posible que las condiciones finales se alcancen en algun paso previo.
// Esto permite generar nuevas teorias, pero quita performance al proceso de ejecucion.
//#define VERIFICAL_RESULTADOS_EN_CADA_PASO             true


// [Planificador]

// Cantidad maxima de pasos que puede tener un plan.
// Cuanto mas grande sea este numero, mas ciclos puede tardar el proceso de planificacion.
// Este valor es un compromiso entre performance y eficiencia.
#define PASOS_MAXIMOS_DE_PLAN           20

// El metodo de planificacion puede encontrar varios planes, y de ellos elige el mejor.
// Si se hace seleccionar TODOS los posibles planes, puede tardar demasiado.
// Una opcion es determinar una cantidad maxima de posibles planes que se pueden testear.
// Este valor es un compromiso entre performance y eficiencia.
// Poner INFINITO si se desea deshabilitar esta opcion.
#define PLANES_MAXIMOS_TESTEADOS        10

// Es la minima relacion P/K que puede tener una teoria para considerarse como aceptable.
#define TOLERANCIA                                      0.75


// [Heuristicas]

// Cantidad de ciclos que se recuerda una teoria.
// Poner INFINITO si se desea deshabilitar esta opcion.
#define CICLOS_DE_MEMORIA                       10




bool cumple_condiciones (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;




// CTeoria
template < typename E >
class CTeoria
{
public:

        std::string                             nombre ;

        // Condiciones iniciales de la teoria.
        // Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.
        // Las condiciones se concatenan con un operador &&
        CIndiceMagico<t_dato>   datos_iniciales ;
        
        // Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial
        CIndiceMagico<t_dato>   datos_finales ;

        // Entorno sobre el cual trabajar
        E& entorno;

public:

        CTeoria(const std::string& ini_nombre, 
                        unsigned long ini_k,
                        unsigned long ini_p,
                        E& e):
                nombre(ini_nombre),
                k(ini_k),
                p(ini_p),
                entorno(e)
        {}

        // La funcion que se debe ejecutar para hacer valer la teoria.
        virtual double funcion() = 0;

public: 
        // Cantidad de veces que se probo la teoria.
        unsigned long                   k ;
        
        // Cantidad de veces que se probo la teoria y resulto correcta.
        unsigned long                   p ;

        // Cantidad de ciclos ocurridos desde que se creo la teoria.
        // Este parametro se usa para quitarle memoria al SA.
        unsigned long                   ciclos ;

} ;



// CEntorno
class CEntorno
{
public:
        CIndiceMagico<t_dato>   datos ;

public:
        // Actualizar los datos
        virtual void actualizar() = 0 ;

        virtual ~CEntorno() {}
} ;



// CSistemaAutonomo
template < typename E >
class CSistemaAutonomo
{
public:
        // El entono en el que se mueve el SA.
        E&                              entorno ;

        // Las teorias que tiene el SA.
        CIndiceMagico< CTeoria< E >* >  teorias ;

        ~CSistemaAutonomo()
        {
                for (int i = 0; i < teorias.m_cant; ++i)
                {
                        delete teorias.m_datos[i];
                }
        }


public:
        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool verificar_condicion(CIndiceMagico<t_dato>& datos)
        {
                bool result = true ;
                unsigned i ;


                for (i=0; i<datos.count() && result; i++)
                        result = datos[i] == this->p_entorno->datos.find(datos.keys(i))  ;


                //
                return result ;
        }


protected: 

        // Heuristica de observacion.
        //      Segun la teoria que se ejecuto, se crea una nueva teoria con TODOS/ALGUNOS valores actuales del entorno como condicion_final.
        void heurisitca_observacion(CTeoria< E >&)
        {
        }

        // Heuristica de correccion por retraccion.
        //      Si una teoria no se verifico como correcta, se crea una nueva quitandole las condiciones_finales que no se verifican.
        void heurisitca_retraccion(CTeoria< E >&)
        {
        }



protected:
        // Planificador: Se encaga de encontrar una serie de teorias que logren hacer
        //                              cumplir la condicion_final, partiendo de la condicion_inicial.
        // Parametros:
        //              datos_iniciales: Forman la condicion inicial.
        //              datos_finales:   Forman la condicion final.
        CIndiceMagico<CTeoria< E >* >*          planificar (
                        CIndiceMagico<t_dato>&  datos_iniciales,
                        CIndiceMagico<t_dato>&  datos_finales,
                        CIndiceMagico<CTeoria< E >* >& plan,
                        unsigned long numero_de_llamada,
                        double& p) ;

public:

        CSistemaAutonomo(E& e): entorno(e) {}

        CIndiceMagico<CTeoria< E >* >* new_plan(CIndiceMagico< t_dato >& datos_finales, double& p)
        {
                CIndiceMagico<CTeoria< E >* >   plan ;
                return planificar(entorno.datos, datos_finales, plan, 0, p) ;
        }


        // Ejecuta una serie de pasos.
        // Retorna true si se alcanza la condicion final.
        bool ejecutar (CIndiceMagico<CTeoria< E > >& plan) ;


} ;


//--------------------------------------------------------------------------------------------
//-- PROBAR BIEN
template < typename E >
CIndiceMagico< CTeoria< E >* >* CSistemaAutonomo< E >::planificar (
                CIndiceMagico< t_dato >&        datos_iniciales,
                CIndiceMagico< t_dato >&        datos_finales,
                CIndiceMagico< CTeoria< E >* >& plan,
                unsigned long numero_de_llamada,
                double& p)
{
        unsigned                                                                        i ;
        double                                                                          nuevo_p ; 
        double                                                                          max_p = 0 ;
        CIndiceMagico< CTeoria< E >* >*                                         p_nuevo_plan ;
        CIndiceMagico< CTeoria< E >* >*                                         pResult = NULL ;
        CIndiceMagico< CIndiceMagico< CTeoria< E >* > >         planes ;
        

        for (i=0; i<this->teorias.count(); i++)
        {
                // Si la teoria cumple la condicion inicial
                if ( cumple_condiciones(this->teorias[i]->datos_iniciales, datos_iniciales) )
                {
                        p_nuevo_plan = new CIndiceMagico< CTeoria< E >* > ;

                        nuevo_p = ( p + ((double)this->teorias[i]->p) / ((double)this->teorias[i]->k) ) / 2 ;
                        
                        // Agrego la teoria al plan
                        p_nuevo_plan->add (this->teorias[i]->nombre.c_str(), this->teorias[i]) ;
                        
                        if (numero_de_llamada<PASOS_MAXIMOS_DE_PLAN)
                        {
                                // Pero si no cumple con la condicion final
                                if ( !cumple_condiciones(datos_finales, this->teorias[i]->datos_finales) )
                                {
                                        planificar (this->teorias[i]->datos_finales,
                                                                datos_finales,
                                                                *p_nuevo_plan,
                                                                numero_de_llamada+1,
                                                                nuevo_p) ;
                                }
                        }

                
                        // Si cumple con la condicion final
                        if (nuevo_p>max_p)
                        {
                                if ( cumple_condiciones(datos_finales, (*p_nuevo_plan)[p_nuevo_plan->count()-1]->datos_finales) )
                                {
                                        max_p = nuevo_p ;

                                        if (pResult) delete pResult ;
                                        
                                        pResult = p_nuevo_plan ;
                                }
                        }
                }       
        }

        //
        return pResult ;
}


//--------------------------------------------------------------------------------------------
//--
template < typename E >
bool CSistemaAutonomo< E >::ejecutar (CIndiceMagico<CTeoria< E > >& plan)
{
        bool result = true ;
        int i ;
        CTeoria< E > t ;        


        for (i=0; i<plan.count() && result; i++)
        {
                t = plan[i] ;

                // Ejecuto la funcion
                t.funcion() ;

                // Incremento el K
                t.k++ ;

                // Actualizo los datos del entorno
                this->p_entorno->actualizar() ;

                // Veo si se verifica la condicion final
                result = this->verificar_condicion(t.datos_finales) ;

                // Si fallo la teoria
                if (!result)
                {
                        // Aplico heuristicas de correccion
                        this->heurisitca_retraccion(t) ;
                }
                else
                {
                        t.p++ ;
                }

                // Aplico heuristicas de observacion
                this->heurisitca_observacion(t) ;
        }

        //
        return result ;
}



#endif