Error bizarro que hizo que no se agreguen estos archivos.

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

diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index 91db5e2a9dc94249e2a2b06af8a2b3cce9e3bffe..4aafef50b086b59f9153ebdf47bc1ebe28d8ada2 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 <map>
+#include <iostream>
 
 
 // DEFINICIONES:
@@ -83,13 +83,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:
 
-       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.
@@ -112,8 +114,8 @@ public:
                p = 1 ;
        }
 
-       CTeoria(const char* ini_nombre, 
-               const char* ini_funcion,
+       CTeoria(const std::string& ini_nombre, 
+               const std::string& ini_funcion,
                        unsigned long ini_k,
                        unsigned long ini_p)
        {
@@ -123,6 +125,29 @@ public:
                p = ini_p ;
        }
 
+//private:
+       CTeoria(const CTeoria& t):
+               nombre(t.nombre),
+               datos_iniciales(t.datos_iniciales),
+               funcion(t.funcion),
+               datos_finales(t.datos_finales),
+               k(t.k),
+               p(t.p)
+       {
+               std::cout << "-----> CTeoria::operator=(" << t << ") <-----\n";
+       }
+       CTeoria& operator= (const CTeoria& t)
+       {
+               std::cout << "-----> " << *this << "::operator=(" << t << ") <-----\n";
+               nombre = t.nombre;
+               funcion = t.funcion;
+               k = t.k;
+               p = t.p;
+               datos_iniciales = t.datos_iniciales;
+               datos_finales = t.datos_finales;
+               return *this;
+       }
+
 
 public:        
        // Cantidad de veces que se probo la teoria.
@@ -137,6 +162,14 @@ public:
 
 } ;
 
+inline
+std::ostream& operator<< (std::ostream& os, const CTeoria& t)
+{
+       return os << "CTeoria(nombre=" << t.nombre << ", funcion=" << t.funcion
+               << ", p=" << t.p << ", k=" << t.k << /*", ciclos=" << t.ciclos <<*/ ")";
+//             << "):\n\tdatos_iniciales:\n" << t.datos_iniciales
+//             << "\tdatos_finales:\n" << t.datos_finales << "\n";
+}
 
 
 // CEntorno
@@ -172,14 +205,19 @@ public:
        CIndiceMagico<t_dato>           m_datos_finales;
 
        // Las teorias que tiene el SA.
-       CIndiceMagico<CTeoria>          teorias ;
+       CIndiceMagico<CTeoria*>         teorias ;
 
 public:
        // Constructor
        CSistemaAutonomo(): p_entorno(new CEntorno) {}
 
        // 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();
@@ -193,36 +231,36 @@ public:
        // 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
-       CIndiceMagico<CTeoria> m_plan;
+       CIndiceMagico<CTeoria*> m_plan;
 
        // 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.
-       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.
-       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.
-       void heurisitca_generalizacion(CTeoria&);
+       void heuristca_generalizacion(CTeoria&);
 
 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) ;