Se mejora lectura del sensor y se elimina variable sin demasiada utilidad.

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

diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index d0355fdd8bfd053e892b8a0f0e60132638a56ea3..a5e71c44ecec3be5ae1f91bc2cc78246415accbf 100644 (file)
--- a/trunk/src/sistemaautonomo.h
+++ b/trunk/src/sistemaautonomo.h
@@ -3,6 +3,10 @@
 #define __SISTEMAAUTONOMO__
 
 #include "indicemagico.h"
 #define __SISTEMAAUTONOMO__
 
 #include "indicemagico.h"

+#include <math.h>
+#include <string>
+//#include <map>
+

 
 // DEFINICIONES:
 // ------------
 
 // DEFINICIONES:
 // ------------


@@ -21,14 +25,17 @@
 
 class CEntorno ;
 
 
 class CEntorno ;
 

+

 typedef double t_dato ;
 typedef double t_dato ;

+#define ANY -3000000
+
+

 #define t_fnc(name)            double (*name)(CEntorno&)
 
 
 #define INFINITO       9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long
 
 
 #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
 
 // ------------------------------------------
 // Parametros de configuracion de SA
 


@@ -72,13 +79,12 @@ typedef double t_dato ;
 
 
 
 
 
 

-bool cumple_condiciones (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
+bool incluye_a (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;

 
 
 
 
 // CTeoria
 
 
 
 
 // CTeoria

-template < typename E >

 class CTeoria
 {
 public:
 class CTeoria
 {
 public:


@@ -89,32 +95,38 @@ public:
        // 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 ;
        // 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 ;

-       
+
+       // La funcion que se debe ejecutar para hacer valer la teoria.
+       double (*funcion)(CEntorno& e) ;
+

        // Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial
        CIndiceMagico<t_dato>   datos_finales ;
 
        // 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:
 public:

+       CTeoria()
+       {
+               nombre = "" ;
+               funcion = NULL ;
+               k = 1 ;
+               p = 1 ;
+       }

 
 

-       CTeoria(const std::string& ini_nombre, 
+       CTeoria(const char* ini_nombre, 
+                       double (*ini_funcion)(CEntorno& e),

                        unsigned long ini_k,
                        unsigned long ini_k,

-                       unsigned long ini_p,
-                       E& e):
-               nombre(ini_nombre),
-               k(ini_k),
-               p(ini_p),
-               entorno(e)
-       {}
+                       unsigned long ini_p)
+       {
+               nombre = ini_nombre ;
+               funcion = ini_funcion ;
+               k = ini_k ;
+               p = ini_p ;
+       }

 
 

-       // 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 ;
 
 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 veces que se probo la teoria y resulto correcta.
        unsigned long                   p ;
 


@@ -133,209 +145,65 @@ public:
        CIndiceMagico<t_dato>   datos ;
 
 public:
        CIndiceMagico<t_dato>   datos ;
 
 public:

+//     CEntorno() { this->inicializar() ; }
+
+public:
+       // Inicializar los datos
+       virtual void inicializar() {} ;
+

        // Actualizar los datos
        // Actualizar los datos

-       virtual void actualizar() = 0 ;
+       virtual void actualizar() {} ;

 
 

+       // Destructor

        virtual ~CEntorno() {}
 } ;
 
 
 
 // CSistemaAutonomo
        virtual ~CEntorno() {}
 } ;
 
 
 
 // CSistemaAutonomo

-template < typename E >

 class CSistemaAutonomo
 {
 public:
        // El entono en el que se mueve el SA.
 class CSistemaAutonomo
 {
 public:
        // El entono en el que se mueve el SA.

-       E&                              entorno ;
+       CEntorno*                                       p_entorno ;

 
        // Las teorias que tiene el SA.
 
        // 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];
-               }
-       }
-
+       CIndiceMagico<CTeoria>          teorias ;

 
 public:
        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
 
 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 ;
-       }
+       bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;

 
 
 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.
 
 
 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 >&)
-       {
-       }
+       void heurisitca_observacion(CTeoria&) ;

 
        // 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.
 
        // 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 >&)
-       {
-       }
-
+       void heurisitca_retraccion(CTeoria&) ;

 
 
 
 

-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:
 
 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) ;
-       }
+       
+       void planificar (       CIndiceMagico<t_dato>&  datos_iniciales,
+                                               CIndiceMagico<t_dato>&  datos_finales,
+                                               CIndiceMagico<CTeoria>& plan,
+                                               double&                                 p,
+                                               unsigned long                   numero_de_llamada=0) ;

 
 
        // Ejecuta una serie de pasos.
        // Retorna true si se alcanza la condicion final.
 
 
        // Ejecuta una serie de pasos.
        // Retorna true si se alcanza la condicion final.

-       bool ejecutar (CIndiceMagico<CTeoria< E > >& plan) ;
+       bool ejecutar (CIndiceMagico<CTeoria>& 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
 
 
 #endif