#include "indicemagico.h"
#include <math.h>
#include <string>
-//#include <map>
+#include <iostream>
// DEFINICIONES:
#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
// 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.
// [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.
+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.
CIndiceMagico<t_dato> 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
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)
{
p = ini_p ;
}
-
public:
// Cantidad de veces que se probo la teoria.
unsigned long k ;
} ;
+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
{
public:
// El entono en el que se mueve el SA.
- CEntorno* p_entorno ;
+ CEntorno* p_entorno ;
+
+ // Datos finales a utilizar al hacer
+ CIndiceMagico<t_dato> m_datos_finales;
// Las teorias que tiene el SA.
- CIndiceMagico<CTeoria> teorias ;
+ CIndiceMagico<CTeoria*> 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<t_dato>& datos) ;
+ // plan actual
+ CIndiceMagico<CTeoria*> m_plan;
+
+ // teoria actual
+ 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&);
+
+ // Purga las teorias que no son muy exitosas.
+ void purgar_teorias();
public:
- void planificar ( CIndiceMagico<t_dato>& datos_iniciales,
- CIndiceMagico<t_dato>& datos_finales,
- CIndiceMagico<CTeoria>& plan,
- double& p,
- unsigned long numero_de_llamada=0) ;
+ 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.
- bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
-
-
+// bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
} ;
projects / z.facultad / 75.68 / celdas.git / blobdiff