X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/44029734cc5263d0548dc78ce9d71c43719d1ea7..23a9bf3c98b449186144927de87462f33dd47587:/trunk/src/sistemaautonomo.h?ds=inline diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h index d0355fd..a5e71c4 100644 --- a/trunk/src/sistemaautonomo.h +++ b/trunk/src/sistemaautonomo.h @@ -3,6 +3,10 @@ #define __SISTEMAAUTONOMO__ #include "indicemagico.h" +#include +#include +//#include + // DEFINICIONES: // ------------ @@ -21,14 +25,17 @@ class CEntorno ; + 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 - // ------------------------------------------ // Parametros de configuracion de SA @@ -72,13 +79,12 @@ typedef double t_dato ; -bool cumple_condiciones (CIndiceMagico&, CIndiceMagico&) ; +bool incluye_a (CIndiceMagico&, CIndiceMagico&) ; // CTeoria -template < typename E > 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 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 datos_finales ; - // Entorno sobre el cual trabajar - E& entorno; - 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_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 ; - + // Cantidad de veces que se probo la teoria y resulto correcta. unsigned long p ; @@ -133,209 +145,65 @@ public: CIndiceMagico datos ; public: +// CEntorno() { this->inicializar() ; } + +public: + // Inicializar los datos + virtual void inicializar() {} ; + // Actualizar los datos - virtual void actualizar() = 0 ; + virtual void actualizar() {} ; + // Destructor virtual ~CEntorno() {} } ; // CSistemaAutonomo -template < typename E > class CSistemaAutonomo { public: // El entono en el que se mueve el SA. - E& entorno ; + CEntorno* p_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]; - } - } - + CIndiceMagico teorias ; public: // Retorna true si los valores de la condicion coinciden con los valores del entorno. - bool verificar_condicion(CIndiceMagico& datos) - { - bool result = true ; - unsigned i ; - - - for (i=0; ip_entorno->datos.find(datos.keys(i)) ; - - - // - return result ; - } + bool verificar_condicion(CIndiceMagico& 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. - 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. - 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* >* planificar ( - CIndiceMagico& datos_iniciales, - CIndiceMagico& datos_finales, - CIndiceMagico* >& plan, - unsigned long numero_de_llamada, - double& p) ; - public: - CSistemaAutonomo(E& e): entorno(e) {} - - CIndiceMagico* >* new_plan(CIndiceMagico< t_dato >& datos_finales, double& p) - { - CIndiceMagico* > plan ; - return planificar(entorno.datos, datos_finales, plan, 0, p) ; - } + + void planificar ( CIndiceMagico& datos_iniciales, + CIndiceMagico& datos_finales, + CIndiceMagico& plan, + double& p, + unsigned long numero_de_llamada=0) ; // Ejecuta una serie de pasos. // Retorna true si se alcanza la condicion final. - bool ejecutar (CIndiceMagico >& plan) ; + bool ejecutar (CIndiceMagico& 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; iteorias.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_llamadateorias[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 >& plan) -{ - bool result = true ; - int i ; - CTeoria< E > t ; - - - for (i=0; ip_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