X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/b3f18bf057bda6df83d7ce7abec0372fd0f101b7..9d2694b6708c33f0eeb0537032687872e0056e4b:/trunk/src/sistemaautonomo.h diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h index ce08cfa..819db8a 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. @@ -57,7 +57,7 @@ typedef double t_dato ; // 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 +#define PASOS_MAXIMOS_DE_PLAN 4 // 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. @@ -66,6 +66,11 @@ typedef double t_dato ; // Poner INFINITO si se desea deshabilitar esta opcion. #define PLANES_MAXIMOS_TESTEADOS 10 +// 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. +#define TEORIAS_MAX 20 + // Es la minima relacion P/K que puede tener una teoria para considerarse como aceptable. #define TOLERANCIA 0.75 @@ -83,13 +88,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 +104,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 +114,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 +130,6 @@ public: p = ini_p ; } - public: // Cantidad de veces que se probo la teoria. unsigned long k ; @@ -137,6 +143,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 +180,78 @@ 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 ; 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(); + + // 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) ; } ;