X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/a4c9e136c32a1686046eaf6c6e1902cac4b7bb73..6566954a731b998269a9f17108ece63b17ccbbbf:/trunk/src/sistemaautonomo.h

diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index dd82f82..91efc99 100644
--- a/trunk/src/sistemaautonomo.h
+++ b/trunk/src/sistemaautonomo.h
@@ -5,7 +5,7 @@
 #include "indicemagico.h"
 #include <math.h>
 #include <string>
-//#include <map>
+#include <iostream>
 
 
 // DEFINICIONES:
@@ -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<t_dato>&, CIndiceMagico<t_dato>&) ;
 
 
 
+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.
@@ -123,7 +120,6 @@ public:
 		p = ini_p ;
 	}
 
-
 public:	
 	// Cantidad de veces que se probo la teoria.
 	unsigned long			k ;
@@ -138,9 +134,12 @@ public:
 } ;
 
 inline
-std::ostream& operator<< (std::ostream& os, CTeoria& t)
+std::ostream& operator<< (std::ostream& os, const CTeoria& t)
 {
-	return os << t.nombre << " > " << t.funcion;
+	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";
 }
 
 
@@ -177,14 +176,32 @@ public:
 	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();
@@ -203,31 +220,34 @@ public:
 	bool verificar_condicion(CIndiceMagico<t_dato>&	datos) ;
 
 	// plan actual
-	CIndiceMagico<CTeoria> m_plan;
+	CIndiceMagico<CTeoria*> m_plan;
 
 	// teoria actual
-	CIndiceMagico<CTeoria>::iterator curr_theory;
+	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,
+			CIndiceMagico<CTeoria*>& plan,
 			double&		p,
 			unsigned long	numero_de_llamada=0) ;