X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/651df9d4bd2ec484ec71c80d7dd2165d7cf4290e..22822a747c21df2f9d99acd8dd2f3f3a9ea54a9a:/trunk/src/sistemaautonomo.h?ds=sidebyside

diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index a7debcd..2a85b5c 100644
--- a/trunk/src/sistemaautonomo.h
+++ b/trunk/src/sistemaautonomo.h
@@ -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.
@@ -125,30 +120,6 @@ public:
 		p = ini_p ;
 	}
 
-//private:
-	CTeoria(const CTeoria& t):
-		nombre(t.nombre),
-		datos_iniciales(t.datos_iniciales),
-		funcion(t.funcion),
-		datos_finales(t.datos_finales),
-		k(t.k),
-		p(t.p)
-	{
-		std::cout << "-----> CTeoria::operator=(" << t << ") <-----\n";
-	}
-	CTeoria& operator= (const CTeoria& t)
-	{
-		std::cout << "-----> " << *this << "::operator=(" << t << ") <-----\n";
-		nombre = t.nombre;
-		funcion = t.funcion;
-		k = t.k;
-		p = t.p;
-		datos_iniciales = t.datos_iniciales;
-		datos_finales = t.datos_finales;
-		return *this;
-	}
-
-
 public:	
 	// Cantidad de veces que se probo la teoria.
 	unsigned long			k ;
@@ -165,10 +136,24 @@ public:
 inline
 std::ostream& operator<< (std::ostream& os, const CTeoria& t)
 {
+#ifdef LOG
+	return os << t.nombre << "," << t.funcion << "," << t.p << "," << t.k;
+#else // ! LOG
 	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";
+		<< ", p=" << t.p << ", k=" << t.k << ")";
+#endif // LOG
+}
+
+template < >
+inline
+std::ostream& operator<< (std::ostream& os, CIndiceMagico<CTeoria*>& im)
+{
+	unsigned c = im.count();
+	if (c-- == 0) return os << "";
+	for (unsigned i = 0; i < c; ++i)
+		os << *im[i] << "\n";
+	os << *im[c];
+	return os;
 }
 
 
@@ -207,12 +192,30 @@ public:
 	// Las teorias que tiene el SA.
 	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();
@@ -250,6 +253,9 @@ protected:
 	// 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 heuristca_generalizacion(CTeoria&);
 
+	// Purga las teorias que no son muy exitosas.
+	void purgar_teorias();
+
 public: