X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/b3f18bf057bda6df83d7ce7abec0372fd0f101b7..fd72896c8b832ca19985ed67f6b1e4d570c85da2:/trunk/src/sistemaautonomo.h?ds=sidebyside diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h index ce08cfa..91efc99 100644 --- a/trunk/src/sistemaautonomo.h +++ b/trunk/src/sistemaautonomo.h @@ -5,7 +5,7 @@ #include "indicemagico.h" #include #include -//#include +#include // DEFINICIONES: @@ -30,7 +30,7 @@ typedef double t_dato ; #define ANY -3000000 -#define t_fnc(name) double (*name)(CEntorno&) +//#define t_fnc(name) double (*name)(CEntorno&) #define INFINITO 9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long @@ -44,7 +44,7 @@ typedef double t_dato ; // Precision en la comparacion de atributos. // Poner en 0 si se quiere hacer la comparacion exacta. -#define PRECISION 0.50000 +#define PRECISION 0.150000 // Cuando se ejecuta un plan, se espera que al termina el ultimo paso se hallan alcanzado las condiciones finales. // Es posible que las condiciones finales se alcancen en algun paso previo. @@ -54,11 +54,6 @@ typedef double t_dato ; // [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. @@ -83,13 +78,15 @@ bool incluye_a (CIndiceMagico&, CIndiceMagico&) ; +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. @@ -97,7 +94,7 @@ public: CIndiceMagico datos_iniciales ; // La funcion que se debe ejecutar para hacer valer la teoria. - double (*funcion)(CEntorno& e) ; + std::string funcion ; // TODO std::string accion; Debería ser el nombre de la acción que va a realizar el BREVE // Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial @@ -107,13 +104,13 @@ public: CTeoria() { nombre = "" ; - funcion = NULL ; + funcion = "" ; k = 1 ; p = 1 ; } - CTeoria(const char* ini_nombre, - double (*ini_funcion)(CEntorno& e), + CTeoria(const std::string& ini_nombre, + const std::string& ini_funcion, unsigned long ini_k, unsigned long ini_p) { @@ -123,7 +120,6 @@ public: p = ini_p ; } - public: // Cantidad de veces que se probo la teoria. unsigned long k ; @@ -137,6 +133,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 @@ -166,51 +170,91 @@ class CSistemaAutonomo { public: // El entono en el que se mueve el SA. - CEntorno* p_entorno ; + CEntorno* p_entorno ; + + // Datos finales a utilizar al hacer + CIndiceMagico m_datos_finales; // Las teorias que tiene el SA. - CIndiceMagico teorias ; + CIndiceMagico 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 - 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 - ~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(); + + // Indica si hay una teoria mas para ejecutar + bool has_next_theory(); + + // Obtiene la próxima teoría del plan actual + CTeoria* get_next_theory(); + + // Retorna true si los valores de la condicion coinciden con los valores del entorno. + bool validate_theory(CTeoria*) ; + +//protected: // Retorna true si los valores de la condicion coinciden con los valores del entorno. bool verificar_condicion(CIndiceMagico& datos) ; + // plan actual + CIndiceMagico m_plan; + + // teoria actual + CIndiceMagico::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&); + + // Purga las teorias que no son muy exitosas. + void purgar_teorias(); public: - void planificar ( CIndiceMagico& datos_iniciales, - CIndiceMagico& datos_finales, - CIndiceMagico& plan, - double& p, - unsigned long numero_de_llamada=0) ; + 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) ; } ;