Subo la versión 1.0.3 con correcciones para que compile y no tire warnings.

diff --git a/trunk/src/Makefile b/trunk/src/Makefile
new file mode 100644 (file)
index 0000000..42ef74e
--- /dev/null
+++ b/trunk/src/Makefile
@@ -0,0 +1,15 @@
+
+CXXFLAGS=-Wall -g
+
+targets=test
+
+all: $(targets)
+test: main.o sistemaautonomo.o
+       $(CXX) $(LDFLAGS) -o test *.o
+
+clean:
+       $(RM) -fv *.o $(target)
+
+depend:
+       makedepend -- $(CFLAGS) -- *.cpp
+

diff --git a/trunk/src/indicemagico.h b/trunk/src/indicemagico.h
index f5a4ac22a6b02ad888f4a33f29b018e6fed3fd1b..4c3396e6769dc9ef179b9dd4fae9ae9507744d52 100644 (file)
--- a/trunk/src/indicemagico.h
+++ b/trunk/src/indicemagico.h
@@ -8,6 +8,7 @@
 
 
 #include <string>
 
 
 #include <string>

+#include <map>

 #include <iostream>
 
 
 #include <iostream>
 
 


@@ -22,18 +23,16 @@ public:
 public:
        CIndiceMagico() 
        { 
 public:
        CIndiceMagico() 
        { 

-               using std::cerr;
-               using std::endl;

                m_cant = 0 ; 
                m_nombres = (std::string*)calloc(sizeof(std::string), MAX_ELEMENTOS) ;
                m_datos = (T*)calloc(sizeof(m_datos), MAX_ELEMENTOS) ;
 
 
                if (!m_nombres)
                m_cant = 0 ; 
                m_nombres = (std::string*)calloc(sizeof(std::string), MAX_ELEMENTOS) ;
                m_datos = (T*)calloc(sizeof(m_datos), MAX_ELEMENTOS) ;
 
 
                if (!m_nombres)

-                       cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres." << endl ;
+                       std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres.\n";

 
                if (!m_datos)
 
                if (!m_datos)

-                       cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos." << endl ;
+                       std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos.\n";

 
        }
 
 
        }
 


@@ -52,14 +51,14 @@ public:
 
        void add(CIndiceMagico<T>& indice)
        {
 
        void add(CIndiceMagico<T>& indice)
        {

-               for (int i=0; i<indice.m_cant; i++)
-                       add(indice.m_nombres[i], indice.m_datos[i]) ;
+               for (unsigned i=0; i<indice.m_cant; i++)
+                       add(indice.m_nombres[i].c_str(), indice.m_datos[i]) ;

        }
 
 
        bool exist(const char* nombre)
        {
        }
 
 
        bool exist(const char* nombre)
        {

-               for (int i=0; i<m_cant; i++)
+               for (unsigned i=0; i<m_cant; i++)

                        if (m_nombres[i]==nombre)
                                return true ;
 
                        if (m_nombres[i]==nombre)
                                return true ;
 


@@ -70,7 +69,7 @@ public:
        //POS: Retorna el elemento.
        T& find(const char* nombre)
        {
        //POS: Retorna el elemento.
        T& find(const char* nombre)
        {

-               int i;
+               unsigned i;

                for (i=0; i<m_cant && m_nombres[i]!=nombre; i++) ;
                return m_datos[i] ;
        }
                for (i=0; i<m_cant && m_nombres[i]!=nombre; i++) ;
                return m_datos[i] ;
        }


@@ -78,7 +77,7 @@ public:
 
        void set_val(const std::string nombre, T valor)
        {
 
        void set_val(const std::string nombre, T valor)
        {

-               for (int i=0; i<m_cant; i++)
+               for (unsigned i=0; i<m_cant; i++)

                        if (m_datos[i]!=valor)
                                m_datos[i] ;
        }
                        if (m_datos[i]!=valor)
                                m_datos[i] ;
        }


@@ -91,7 +90,7 @@ public:
 
        void remove(const unsigned long index)
        {
 
        void remove(const unsigned long index)
        {

-               for (int i=index+1; i<m_cant; i++)
+               for (unsigned i=index+1u; i<m_cant; i++)

                {
                        m_nombres[i-1] = m_nombres[i] ; 
                        m_datos[i-1] = m_datos[i] ; 
                {
                        m_nombres[i-1] = m_nombres[i] ; 
                        m_datos[i-1] = m_datos[i] ; 


@@ -103,7 +102,7 @@ public:
        void remove(const char* nombre)
        {
                bool exito = false ;
        void remove(const char* nombre)
        {
                bool exito = false ;

-               int i;
+               unsigned i;

 
                for (i=0; !exito && i<m_cant; i++)
                        exito = m_nombres[i]==nombre ;
 
                for (i=0; !exito && i<m_cant; i++)
                        exito = m_nombres[i]==nombre ;

diff --git a/trunk/src/main.cpp b/trunk/src/main.cpp
index 648505ac83c9789efe44714f78862d6ed80cb656..a2598050905229e5d04c67105d56d18485dc2fd0 100644 (file)
--- a/trunk/src/main.cpp
+++ b/trunk/src/main.cpp
@@ -1,34 +1,36 @@
+

 #include "main.h"
 #include "main.h"

+#include <iostream>

 
 //
 
 //

-double CMiEntorno::AvanzarX()
+double AvanzarX(CEntorno& e)

 {
        avanzo_en_x = true ;
        return 0 ;
 }
 
 
 {
        avanzo_en_x = true ;
        return 0 ;
 }
 
 

-double CMiEntorno::AvanzarY()
+double AvanzarY(CEntorno& e)

 {
        avanzo_en_y = true ;
        return 0 ;
 }
 
 
 {
        avanzo_en_y = true ;
        return 0 ;
 }
 
 

-double CMiEntorno::AvanzarZ()
+double AvanzarZ(CEntorno& e)

 {
        avanzo_en_z = true ;
        return 0 ;
 }
 
 
 {
        avanzo_en_z = true ;
        return 0 ;
 }
 
 

-CMiEntorno::CMiEntorno():
-       avanzo_en_x(true), avanzo_en_y(true), avanzo_en_z(true)
+//
+void CMiEntorno::inicializar()

 {
        // Inicializo el Entorno
 {
        // Inicializo el Entorno

-       datos.add("robot.avanzo_en_x", 1) ;
-       datos.add("robot.avanzo_en_y", 1) ;
-       datos.add("robot.avanzo_en_z", 1) ;
+       datos.add("robot.avanzo_en_x", 0) ;
+       datos.add("robot.avanzo_en_y", 0) ;
+       datos.add("robot.avanzo_en_z", 0) ;

 
        datos.add("robot.sensor_1", 0) ;
        datos.add("robot.sensor_2", 0) ;
 
        datos.add("robot.sensor_1", 0) ;
        datos.add("robot.sensor_2", 0) ;


@@ -49,76 +51,84 @@ void CMiEntorno::actualizar()
        
 }
 
        
 }
 

-struct CMiTeoria1: CTeoria< CMiEntorno >
-{
-       CMiTeoria1(CMiEntorno& e):
-               CTeoria< CMiEntorno >("Avanzar_X_1", 1, 1, e)
-       {
-               datos_iniciales.add ("robot.sensor_1", 0) ;
-               datos_finales.add ("robot.avanzo_en_x", 1) ;
-       }
-       double funcion()
-       {
-               entorno.avanzo_en_x = true ;
-               return 0 ;
-       }
-};
-
-struct CMiTeoria2: CTeoria< CMiEntorno >
-{
-       CMiTeoria2(CMiEntorno& e):
-               CTeoria< CMiEntorno >("Avanzar_Y_1", 1, 1, e)
-       {
-               datos_iniciales.add ("robot.sensor_2", 0) ;
-               datos_finales.add ("robot.avanzo_en_y", 1) ;
-       }
-       double funcion()
-       {
-               entorno.avanzo_en_y = true ;
-               return 0 ;
-       }
-};
-
-struct CMiTeoria3: CTeoria< CMiEntorno >
-{
-       CMiTeoria3(CMiEntorno& e):
-               CTeoria< CMiEntorno >("Avanzar_Z_1", 1, 1, e)
-       {
-               datos_iniciales.add ("robot.sensor_3", 0) ;
-               datos_finales.add ("robot.avanzo_en_z", 1) ;
-       }
-       double funcion()
-       {
-               entorno.avanzo_en_z = true ;
-               return 0 ;
-       }
-};
+

 
 //
 int main(int argc, char** argv)
 {
        //
 
 //
 int main(int argc, char** argv)
 {
        //

-       CMiEntorno                     e ;
-       CSistemaAutonomo< CMiEntorno > a(e) ;
+       CMiEntorno                              e ;
+       CSistemaAutonomo                a ;

 
 

+       e.inicializar() ;

 
        // Inicializo las teorias
 
        // Inicializo las teorias

-       a.teorias.add("teoria1", new CMiTeoria1(e)) ;
-       a.teorias.add("teoria2", new CMiTeoria2(e)) ;
-       a.teorias.add("teoria3", new CMiTeoria3(e)) ;
+       CTeoria t1("Avanzar_X_1", &AvanzarX, 1, 1) ;
+       t1.datos_iniciales.add ("robot.sensor_1", 0) ;
+       t1.datos_iniciales.add ("robot.sensor_2", ANY) ;
+       t1.datos_iniciales.add ("robot.sensor_3", ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_en_x", ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
+       t1.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
+       t1.datos_finales.add ("robot.avanzo_en_x", 1) ;
+       t1.datos_finales.add ("robot.avanzo_en_y", 0) ;
+       t1.datos_finales.add ("robot.avanzo_en_z", 0) ;
+       t1.datos_finales.add ("robot.sensor_1", ANY) ;
+       t1.datos_finales.add ("robot.sensor_2", ANY) ;
+       t1.datos_finales.add ("robot.sensor_3", ANY) ;
+
+       CTeoria t2("Avanzar_Y_1", &AvanzarY, 1, 1) ;
+       t2.datos_iniciales.add ("robot.sensor_1", ANY) ;
+       t2.datos_iniciales.add ("robot.sensor_2", 0) ;
+       t2.datos_iniciales.add ("robot.sensor_3", ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_en_x", ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
+       t2.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
+       t2.datos_finales.add ("robot.avanzo_en_x", 0) ;
+       t2.datos_finales.add ("robot.avanzo_en_y", 1) ;
+       t2.datos_finales.add ("robot.avanzo_en_z", 0) ;
+       t2.datos_finales.add ("robot.sensor_1", ANY) ;
+       t2.datos_finales.add ("robot.sensor_2", ANY) ;
+       t2.datos_finales.add ("robot.sensor_3", ANY) ;
+
+       CTeoria t3("Avanzar_Z_1", &AvanzarZ, 1, 1) ;
+       t3.datos_iniciales.add ("robot.sensor_1", ANY) ;
+       t3.datos_iniciales.add ("robot.sensor_2", ANY) ;
+       t3.datos_iniciales.add ("robot.sensor_3", 0) ;
+       t3.datos_iniciales.add ("robot.avanzo_en_x", ANY) ;
+       t3.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
+       t3.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
+       t3.datos_finales.add ("robot.avanzo_en_x", 0) ;
+       t3.datos_finales.add ("robot.avanzo_en_y", 0) ;
+       t3.datos_finales.add ("robot.avanzo_en_z", 1) ;
+       t3.datos_finales.add ("robot.sensor_1", ANY) ;
+       t3.datos_finales.add ("robot.sensor_2", ANY) ;
+       t3.datos_finales.add ("robot.sensor_3", ANY) ;
+
+       a.teorias.add(t1.nombre.c_str(), t1) ;
+       a.teorias.add(t2.nombre.c_str(), t2) ;
+       a.teorias.add(t3.nombre.c_str(), t3) ;
+
+       
+       // Inicializo el SA
+       a.p_entorno = (CEntorno*)(&e) ;

 
 
        // Obtengo un plan
        double p = 1 ;
 
 
        // Obtengo un plan
        double p = 1 ;

-       CIndiceMagico<CTeoria< CMiEntorno >* >* p_plan ;
+       CIndiceMagico<CTeoria> plan ;

        CIndiceMagico<t_dato> datos_finales ;
        CIndiceMagico<t_dato> datos_finales ;

+ 
+       datos_finales.add ("robot.avanzo_en_y", 1) ;
+
+       a.planificar (a.p_entorno->datos, datos_finales, plan, p) ;

 
 

-       datos_finales.add ("robot.avanzo_en_x", 1) ;
+       for (unsigned i=0; i<plan.count(); i++)
+               std::cout << plan[i].nombre.c_str() << std::endl ;

 
 

-       p_plan = a.new_plan(datos_finales, p) ;

 
 

-       for (int i=0; i<p_plan->count(); i++)
-               std::cout << (*p_plan)[i]->nombre << std::endl ;
+       // Ejecuto el plan
+       a.ejecutar(plan) ;

 
 
        return 0 ;
 
 
        return 0 ;

diff --git a/trunk/src/main.h b/trunk/src/main.h
index 1c551bddf7382631b6bb18d6eba37c4afb9529a0..5cbb72f77f916fb9e16187127700fd608565b4d9 100644 (file)
--- a/trunk/src/main.h
+++ b/trunk/src/main.h
@@ -1,29 +1,31 @@
+

 #include "sistemaautonomo.h"
 
 #include "sistemaautonomo.h"
 

-// Entono especializado
-struct CMiEntorno : CEntorno
-{
-public:

 
 

-       // Variables que definien el entorno REAL
-       double sensor_1 ;
-       double sensor_2 ;
-       double sensor_3 ;
+// Variables que definien el entorno REAL
+static double sensor_1 = 0 ;
+static double sensor_2 = 0 ;
+static double sensor_3 = 0 ;

 
 

-       bool avanzo_en_x ;
-       bool avanzo_en_y ;
-       bool avanzo_en_z ;
+static bool avanzo_en_x = false ;
+static bool avanzo_en_y = false ;
+static bool avanzo_en_z = false ;

 
 

-       CMiEntorno() ;
-       virtual void actualizar() ;

 
 

-       // Funciones que usa el SA para modificar el entorno
-       double AvanzarX();
-       double AvanzarY();
-       double AvanzarZ();
+// Funciones que usa el SA para modificar el entorno
+double AcanzarX(CEntorno& e);
+double AcanzarY(CEntorno& e);
+double AcanzarZ(CEntorno& e);
+
+
+// Entono especializado
+class CMiEntorno : CEntorno
+{
+public:
+       virtual void inicializar() ;
+       virtual void actualizar() ;

 } ;
 
 
 // Main
 int main(int, char**) ;
 } ;
 
 
 // Main
 int main(int, char**) ;

-

diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp
index f4cbbabe9b918b575997e7f4c2ba5fe2997c8b54..5f1cf2c7b12b221b89cecaf6b5b185bfd4a1c0f6 100644 (file)
--- a/trunk/src/sistemaautonomo.cpp
+++ b/trunk/src/sistemaautonomo.cpp
@@ -4,19 +4,170 @@
 
 //--------------------------------------------------------------------------------------------
 //-- Funciones Auxiliares
 
 //--------------------------------------------------------------------------------------------
 //-- Funciones Auxiliares

+bool incluye_a (CIndiceMagico<t_dato>& a, CIndiceMagico<t_dato>& b) 
+{
+       bool result = true ;
+       unsigned i ;

 
 

+       // Todas las variables de la condicion b deben estar en la condicion a
+       for (i=0; i<b.count() && result; i++)
+               result=a.exist(b.keys(i)) ;
+
+       // Todas las variables de la condicion a deben tener el mismo valor que en la condicion b
+       for (i=0; i<b.count() && result; i++)
+               result = b[i] == a.find(b.keys(i)) || b[i] == ANY || a.find(b.keys(i)) == ANY  ;
+       //
+       return result ;
+}

 
 

-bool cumple_condiciones (CIndiceMagico<t_dato>& muestra, CIndiceMagico<t_dato>& patron) 
-{

 
 

+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>&      datos)
+{

        bool result = true ;
        unsigned i ;
 
        bool result = true ;
        unsigned i ;
 

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

 
        //
        return result ;
 
        //
        return result ;

+}
+

 
 

+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
+{
+       CTeoria nt ; //Nueva Teoria
+       unsigned i ;
+       std::string nombre ;
+       
+       // Le agrego los datos iniciales tal cual estaban antes
+       for (i=0; i<t.datos_iniciales.count(); i++)
+               nt.datos_iniciales.add(t.datos_iniciales.keys(i), t.datos_iniciales[i]) ;
+
+       // Le agrego todas las condiciones del entorno como condicion final
+       for (i=0; i<this->p_entorno->datos.count(); i++)
+               nt.datos_finales.add(this->p_entorno->datos.keys(i), this->p_entorno->datos[i]) ;
+
+
+       // Agrego la teoria
+       nombre = teorias.count() ;
+       teorias.add (nombre.c_str(), nt) ;
+       

 }
 
 }
 

+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
+{
+       CTeoria nt ; //Nueva Teoria
+       unsigned i ;
+
+       // Recorro la condicion final de la teoria
+       for (i=0; i<t.datos_finales.count(); i++)
+               // Si el dato no coincidio con el del entorno, y no era ANY
+               if (t.datos_finales[i] != ANY && 
+                       t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
+                  )
+                       // Le asigno ANY
+                       t.datos_finales[i] = ANY ;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::planificar (    CIndiceMagico<t_dato>&  datos_iniciales,
+                                                                       CIndiceMagico<t_dato>&  datos_finales,
+                                                                       CIndiceMagico<CTeoria>& plan,
+                                                                       double&                                 p,
+                                                                       unsigned long                   numero_de_llamada)
+{
+       unsigned i;
+       CIndiceMagico<CTeoria> test_plan ;
+       CIndiceMagico<CTeoria> new_plan ;
+       double test_p ;
+       double max_p = 0 ;
+
+
+       if ( incluye_a(datos_iniciales, datos_finales) ) return ;
+
+       if ( numero_de_llamada > 7 ) return ;
+
+       for (i=0; i<teorias.count(); i++)
+               if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
+               {
+                       test_plan.clear() ;
+                       test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
+
+                       test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ;
+
+                       planificar(teorias[i].datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ; 
+                       
+                       if ( test_p>max_p )
+                       if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
+                       {
+                               max_p = test_p ;
+                               new_plan.clear() ;
+                               new_plan.add (test_plan) ;
+                       }
+               }
+
+       if (max_p>0)
+               plan.add (new_plan) ;
+}
+
+
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
+{
+       bool result = true ;
+       unsigned i ;
+       t_fnc(pFnc) ;
+       CTeoria t ;     
+
+
+       for (i=0; i<plan.count() && result; i++)
+       {
+               t = plan[i] ;
+               pFnc = t.funcion;
+
+               // Ejecuto la funcion
+               (*pFnc)(*(this->p_entorno)) ;
+
+               // 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 ;
+}

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