Últimos cambios y documentación.

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

diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index fa833486ce3b6baa1835487bdde99a5918cbefe4..2a85b5c56d42df307c6c61f143d47a6106d31bd5 100644 (file)
--- a/trunk/src/sistemaautonomo.h
+++ b/trunk/src/sistemaautonomo.h
@@ -5,7 +5,7 @@
 #include "indicemagico.h"
 #include <math.h>
 #include <string>
 #include "indicemagico.h"
 #include <math.h>
 #include <string>

-//#include <map>
+#include <iostream>

 
 
 // DEFINICIONES:
 
 
 // DEFINICIONES:


@@ -54,11 +54,6 @@ typedef double t_dato ;
 
 // [Planificador]
 
 
 // [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.
 // 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.


@@ -83,13 +78,15 @@ bool incluye_a (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
 
 
 
 
 
 

+class CTeoria;
+std::ostream& operator<< (std::ostream& os, const CTeoria& t);

 
 // CTeoria
 class CTeoria
 {
 public:
 
 
 // CTeoria
 class CTeoria
 {
 public:
 

-       std::string                             nombre ;
+       std::string             nombre ;

 
        // Condiciones iniciales de la teoria.
        // Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.
 
        // Condiciones iniciales de la teoria.
        // Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.


@@ -123,7 +120,6 @@ public:
                p = ini_p ;
        }
 
                p = ini_p ;
        }
 

-

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


@@ -137,6 +133,28 @@ public:
 
 } ;
 
 
 } ;
 

+inline
+std::ostream& operator<< (std::ostream& os, const CTeoria& t)
+{
+#ifdef LOG
+       return os << t.nombre << "," << t.funcion << "," << t.p << "," << t.k;
+#else // ! LOG
+       return os << "CTeoria(nombre=" << t.nombre << ", funcion=" << t.funcion
+               << ", p=" << t.p << ", k=" << t.k << ")";
+#endif // LOG
+}
+
+template < >
+inline
+std::ostream& operator<< (std::ostream& os, CIndiceMagico<CTeoria*>& im)
+{
+       unsigned c = im.count();
+       if (c-- == 0) return os << "";
+       for (unsigned i = 0; i < c; ++i)
+               os << *im[i] << "\n";
+       os << *im[c];
+       return os;
+}

 
 
 // CEntorno
 
 
 // CEntorno


@@ -172,14 +190,32 @@ public:
        CIndiceMagico<t_dato>           m_datos_finales;
 
        // Las teorias que tiene el SA.
        CIndiceMagico<t_dato>           m_datos_finales;
 
        // Las teorias que tiene el SA.

-       CIndiceMagico<CTeoria>          teorias ;
+       CIndiceMagico<CTeoria*>         teorias ;
+
+       // 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.
+       unsigned max_pasos;
+
+       // Cantidad máxima de teorías que puede tener el planificador. Al haber muchas teorías el
+       // tarda demasiado tiempo en planificar, por lo tanto es necesario sacar algunas teorías
+       // para que sea utilizable. El valor en realidad no es la cantidad máxima, pueden haber
+       // más, pero en cada nueva planificación se seleccionan las mejores max_teorias teorias.
+       unsigned max_teorias;

 
 public:
        // Constructor
 
 public:
        // Constructor

-       CSistemaAutonomo(): p_entorno(new CEntorno) {}
+       CSistemaAutonomo(unsigned max_pasos = 4, unsigned max_teorias = 15):
+               p_entorno(new CEntorno), max_pasos(max_pasos),
+               max_teorias(max_teorias) {}

 
        // Destructor
 
        // Destructor

-       ~CSistemaAutonomo() { delete p_entorno; }
+       ~CSistemaAutonomo()
+       {
+               delete p_entorno;
+               for (unsigned i = 0; i < teorias.count(); ++i)
+                       delete teorias[i];
+       }

 
        // Genera un nuevo plan
        void plan();
 
        // Genera un nuevo plan
        void plan();


@@ -193,36 +229,39 @@ public:
        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool validate_theory(CTeoria*) ;
 
        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool validate_theory(CTeoria*) ;
 

-protected:
+//protected:

        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;
 
        // plan actual
        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;
 
        // plan actual

-       CIndiceMagico<CTeoria> m_plan;
+       CIndiceMagico<CTeoria*> m_plan;

 
        // teoria actual
 
        // teoria actual

-       CIndiceMagico<CTeoria>::iterator curr_theory;
+       CIndiceMagico<CTeoria*>::iterator curr_theory;

 
 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&) ;
+       void heuristca_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&) ;
+       void heuristca_retraccion(CTeoria&) ;

 
        //Heuristica de generalizacion.
        // Si dentro de las teorias se encuentra unaque solo difiera de los datos del entorno en una condicíon inicial => se agrega una nueva teoria igual pero con ANY en esa condicion.
 
        //Heuristica de generalizacion.
        // Si dentro de las teorias se encuentra unaque solo difiera de los datos del entorno en una condicíon inicial => se agrega una nueva teoria igual pero con ANY en esa condicion.

-       void heurisitca_generalizacion(CTeoria&);
+       void heuristca_generalizacion(CTeoria&);
+
+       // Purga las teorias que no son muy exitosas.
+       void purgar_teorias();

 
 public:
 
        
        void planificar (CIndiceMagico<t_dato>& datos_iniciales,
                        CIndiceMagico<t_dato>&  datos_finales,
 
 public:
 
        
        void planificar (CIndiceMagico<t_dato>& datos_iniciales,
                        CIndiceMagico<t_dato>&  datos_finales,

-                       CIndiceMagico<CTeoria>& plan,
+                       CIndiceMagico<CTeoria*>& plan,

                        double&         p,
                        unsigned long   numero_de_llamada=0) ;
 
                        double&         p,
                        unsigned long   numero_de_llamada=0) ;