From: Leandro Lucarella <llucax@gmail.com>
Date: Sat, 16 Dec 2006 17:07:28 +0000 (+0000)
Subject: Bugfixes varios. Lo más importante es que ahora se almacenan las teorías en los plane... 
X-Git-Tag: entrega-20061218~25
X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/commitdiff_plain/651df9d4bd2ec484ec71c80d7dd2165d7cf4290e

Bugfixes varios. Lo más importante es que ahora se almacenan las teorías en los planes (y en el sistema autónomo) como punteros en vez de copias. Las copias producían grandes problemas de performance y lo que es peor, que no permitían que algunas heurísticas tengan efecto porque se modificaban las copias en vez de los originales.

Haciendo pruebas básicas parece que ahora el sistema autónomo anda jamón =)
---

diff --git a/trunk/src/main.cpp b/trunk/src/main.cpp
index 3076aa1..ea0826e 100644
--- a/trunk/src/main.cpp
+++ b/trunk/src/main.cpp
@@ -5,6 +5,16 @@
 //
 void CMiEntorno::inicializar()
 {
+	// Inicializo el Entorno
+	datos.add("robot.sensor_adelante",	1) ;
+	datos.add("robot.sensor_atras",		0) ;
+	datos.add("robot.sensor_derecha",	0) ;
+	datos.add("robot.sensor_izquierda", 0) ;
+	datos.add("robot.avanzo_adelante",	0) ;
+	datos.add("robot.avanzo_atras",		0) ;
+	datos.add("robot.avanzo_derecha",	0) ;
+	datos.add("robot.avanzo_izquierda", 0) ;
+/*
 	// Inicializo el Entorno
 	datos.add("robot.avanzo_en_x", 0) ;
 	// old datos.add("robot.avanzo_en_y", 0) ;
@@ -14,11 +24,22 @@ void CMiEntorno::inicializar()
 	datos.add("robot.sensor_2", 0) ;
 	datos.add("robot.sensor_3", 0) ;
 	datos.add("robot.sensor_4", 0) ; // new
+*/
 }
 
 
 void CMiEntorno::actualizar()
 {
+	datos.find("robot.avanzo_adelante")		= 0 ;
+	datos.find("robot.avanzo_atras")		= 0 ;
+	datos.find("robot.avanzo_derecha")		= 0 ;
+	datos.find("robot.avanzo_izquierda")		= 0 ;
+	datos.find("robot.sensor_adelante")		= 0 ;
+	datos.find("robot.sensor_atras")		= 0 ;
+	datos.find("robot.sensor_derecha")		= 0 ;
+	datos.find("robot.sensor_izquierda")		= 0 ;
+
+/*
 	datos.find("robot.sensor_1") = sensor_1 ;
 	datos.find("robot.sensor_2") = sensor_2 ;
 	datos.find("robot.sensor_3") = sensor_3 ;
@@ -27,7 +48,7 @@ void CMiEntorno::actualizar()
 	datos.find("robot.avanzo_en_x") = avanzo_en_x?1:0 ;
 	datos.find("robot.avanzo_en_y") = avanzo_en_y?1:0 ;
 	datos.find("robot.avanzo_en_z") = avanzo_en_z?1:0 ;
-
+*/
 	
 }
 
@@ -87,6 +108,7 @@ int main(int argc, char* argv[])
 	t3.datos_finales.add ("robot.sensor_3", ANY) ;
 */
 
+/*
 	// Inicializo las teorias
 	CTeoria t1("Avanzar_X_1", "AvanzarX", 1, 1) ;
 	t1.datos_iniciales.add ("robot.sensor_1", ANY) ;
@@ -113,6 +135,7 @@ int main(int argc, char* argv[])
 	t2.datos_finales.add ("robot.sensor_3", ANY) ;
 	t2.datos_finales.add ("robot.sensor_4", ANY) ;
 
+
 	a.teorias.add(t1.nombre.c_str(), t1) ;
 	a.teorias.add(t2.nombre.c_str(), t2) ;
 	// OLD a.teorias.add(t3.nombre.c_str(), t3) ;
@@ -125,38 +148,136 @@ int main(int argc, char* argv[])
 	std::cout << "  .datos_finales:\n" << t2.datos_finales << "\n";
 #endif // DEBUG
 
-	
+*/
+
+	// Inicializo las teorias
+	CTeoria t1("Avanzar", "avanzar", 1, 1) ;
+	t1.datos_iniciales.add ("robot.sensor_adelante",	0) ;
+	t1.datos_iniciales.add ("robot.sensor_atras",		ANY) ;
+	t1.datos_iniciales.add ("robot.sensor_derecha",		ANY) ;
+	t1.datos_iniciales.add ("robot.sensor_izquierda",	ANY) ;
+	t1.datos_iniciales.add ("robot.avanzo_adelante",	ANY) ;
+	t1.datos_iniciales.add ("robot.avanzo_atras",		ANY) ;
+	t1.datos_iniciales.add ("robot.avanzo_derecha",		ANY) ;
+	t1.datos_iniciales.add ("robot.avanzo_izquierda",	ANY) ;	
+	t1.datos_finales.add ("robot.sensor_adelante",		ANY) ;
+	t1.datos_finales.add ("robot.sensor_atras",		ANY) ;
+	t1.datos_finales.add ("robot.sensor_derecha",		ANY) ;
+	t1.datos_finales.add ("robot.sensor_izquierda",		ANY) ;
+	t1.datos_finales.add ("robot.avanzo_adelante",		1) ;
+	t1.datos_finales.add ("robot.avanzo_atras",		0) ;
+	t1.datos_finales.add ("robot.avanzo_derecha",		0) ;
+	t1.datos_finales.add ("robot.avanzo_izquierda",		0) ;
+
+
+	CTeoria t2("Retroceder", "retroceder", 1, 1) ;
+	t2.datos_iniciales.add ("robot.sensor_adelante",	ANY) ;
+	t2.datos_iniciales.add ("robot.sensor_atras",		0) ;
+	t2.datos_iniciales.add ("robot.sensor_derecha",		ANY) ;
+	t2.datos_iniciales.add ("robot.sensor_izquierda",	ANY) ;
+	t2.datos_iniciales.add ("robot.avanzo_adelante",	ANY) ;
+	t2.datos_iniciales.add ("robot.avanzo_atras",		ANY) ;
+	t2.datos_iniciales.add ("robot.avanzo_derecha",		ANY) ;
+	t2.datos_iniciales.add ("robot.avanzo_izquierda",	ANY) ;	
+	t2.datos_finales.add ("robot.sensor_adelante",		ANY) ;
+	t2.datos_finales.add ("robot.sensor_atras",		ANY) ;
+	t2.datos_finales.add ("robot.sensor_derecha",		ANY) ;
+	t2.datos_finales.add ("robot.sensor_izquierda",		ANY) ;
+	t2.datos_finales.add ("robot.avanzo_adelante",		0) ;
+	t2.datos_finales.add ("robot.avanzo_atras",		1) ;
+	t2.datos_finales.add ("robot.avanzo_derecha",		0) ;
+	t2.datos_finales.add ("robot.avanzo_izquierda",		0) ;
+
+
+	CTeoria t3("Derecha", "derecha", 1, 1) ;
+	t3.datos_iniciales.add ("robot.sensor_adelante",	ANY) ;
+	t3.datos_iniciales.add ("robot.sensor_atras",		ANY) ;
+	t3.datos_iniciales.add ("robot.sensor_derecha",		0) ;
+	t3.datos_iniciales.add ("robot.sensor_izquierda",	ANY) ;
+	t3.datos_iniciales.add ("robot.avanzo_adelante",	ANY) ;
+	t3.datos_iniciales.add ("robot.avanzo_atras",		ANY) ;
+	t3.datos_iniciales.add ("robot.avanzo_derecha",		ANY) ;
+	t3.datos_iniciales.add ("robot.avanzo_izquierda",	ANY) ;	
+	t3.datos_finales.add ("robot.sensor_adelante",		ANY) ;
+	t3.datos_finales.add ("robot.sensor_atras",		ANY) ;
+	t3.datos_finales.add ("robot.sensor_derecha",		ANY) ;
+	t3.datos_finales.add ("robot.sensor_izquierda",		ANY) ;
+	t3.datos_finales.add ("robot.avanzo_adelante",		0) ;
+	t3.datos_finales.add ("robot.avanzo_atras",		0) ;
+	t3.datos_finales.add ("robot.avanzo_derecha",		1) ;
+	t3.datos_finales.add ("robot.avanzo_izquierda",		0) ;
+
+
+	CTeoria t4("Eludir.1", "derecha", 1, 1) ;
+	t4.datos_iniciales.add ("robot.sensor_adelante",	1) ;
+	t4.datos_iniciales.add ("robot.sensor_atras",		ANY) ;
+	t4.datos_iniciales.add ("robot.sensor_derecha",		0) ;
+	t4.datos_iniciales.add ("robot.sensor_izquierda",	ANY) ;
+	t4.datos_iniciales.add ("robot.avanzo_adelante",	ANY) ;
+	t4.datos_iniciales.add ("robot.avanzo_atras",		ANY) ;
+	t4.datos_iniciales.add ("robot.avanzo_derecha",		ANY) ;
+	t4.datos_iniciales.add ("robot.avanzo_izquierda",	ANY) ;	
+	t4.datos_finales.add ("robot.sensor_adelante",		0) ;
+	t4.datos_finales.add ("robot.sensor_atras",		ANY) ;
+	t4.datos_finales.add ("robot.sensor_derecha",		ANY) ;
+	t4.datos_finales.add ("robot.sensor_izquierda",		ANY) ;
+	t4.datos_finales.add ("robot.avanzo_adelante",		0) ;
+	t4.datos_finales.add ("robot.avanzo_atras",		ANY) ;
+	t4.datos_finales.add ("robot.avanzo_derecha",		1) ;
+	t4.datos_finales.add ("robot.avanzo_izquierda",		ANY) ;
+
+
+	a.teorias.add(t1.nombre, &t1) ;
+	a.teorias.add(t2.nombre, &t2) ;
+	a.teorias.add(t3.nombre, &t3) ;
+	a.teorias.add(t4.nombre, &t4) ;
+#ifdef DEBUG
+	std::cout << "Agrega teoria: " << t1 << "\n";
+	std::cout << "\tdatos_iniciales:\n" << t1.datos_iniciales << "\n";
+	std::cout << "\tdatos_finales:\n" << t1.datos_finales << "\n";
+	std::cout << "Agrega teoria: " << t2 << "\n";
+	std::cout << "\tdatos_iniciales:\n" << t2.datos_iniciales << "\n";
+	std::cout << "\tdatos_finales:\n" << t2.datos_finales << "\n";
+	std::cout << "Agrega teoria: " << t3 << "\n";
+	std::cout << "\tdatos_iniciales:\n" << t3.datos_iniciales << "\n";
+	std::cout << "\tdatos_finales:\n" << t3.datos_finales << "\n";
+	std::cout << "Agrega teoria: " << t4 << "\n";
+	std::cout << "\tdatos_iniciales:\n" << t4.datos_iniciales << "\n";
+	std::cout << "\tdatos_finales:\n" << t4.datos_finales << "\n";
+#endif // DEBUG
+
 	// Inicializo el SA
 	delete a.p_entorno;
 	a.p_entorno = e;
 
-
 	// Obtengo un plan
 	CIndiceMagico<t_dato> datos_finales;
 
-	a.m_datos_finales.add ("robot.avanzo_en_x", 1) ;
-	a.plan();
-	for (unsigned i=0; i<a.m_plan.count(); i++)
-		std::cout << a.m_plan[i].nombre.c_str() << std::endl ;
-	
-	if (a.has_next_theory())
-	{
-		CTeoria* t = a.get_next_theory();
-		if (a.validate_theory(t))
-			std::cout << "Valida\n";
-	}
- 
-//	datos_finales.add ("robot.avanzo_en_x", 1) ;
+	a.m_datos_finales.add ("robot.avanzo_adelante", 1) ;
+	//a.m_datos_finales.add ("robot.avanzo_en_x", 1) ;
 
-//	a.planificar (a.p_entorno->datos, datos_finales, plan, p) ;
+	for (int i = 0; i < 3; ++i)
+	{
 
-//	for (unsigned i=0; i<plan.count(); i++)
-//		std::cout << plan[i].nombre.c_str() << std::endl ;
+		std::cout << "Teorias:\n" << a.teorias << "\n";
 
+		a.plan();
 
-	// Ejecuto el plan
-//	a.ejecutar(plan) ;
+		while (a.has_next_theory())
+		{
+			CTeoria* t = a.get_next_theory();
+			if (a.validate_theory(t))
+			{
+				std::cout << "Valida\n";
+			}
+			else
+			{
+				std::cout << "No valida, planificamos de nuevo\n";
+				break;
+			}
+		}
 
+	}
 
 	return 0 ;
 }
diff --git a/trunk/src/main.h b/trunk/src/main.h
index fdfbb4e..1a1fef8 100644
--- a/trunk/src/main.h
+++ b/trunk/src/main.h
@@ -3,6 +3,7 @@
 
 
 // Variables que definien el entorno REAL
+/*
 static double sensor_1 = 0 ;
 static double sensor_2 = 0 ;
 static double sensor_3 = 0 ;
@@ -10,7 +11,7 @@ static double sensor_3 = 0 ;
 static bool avanzo_en_x = false ;
 static bool avanzo_en_y = false ;
 static bool avanzo_en_z = false ;
-
+*/
 
 // Funciones que usa el SA para modificar el entorno
 double AcanzarX(CEntorno& e);
diff --git a/trunk/src/plugin.cpp b/trunk/src/plugin.cpp
index 5ac1614..20096f3 100644
--- a/trunk/src/plugin.cpp
+++ b/trunk/src/plugin.cpp
@@ -72,7 +72,7 @@ int SAbrSistemaAutonomoAddTeoria(brEval args[], brEval* result, void* data)
 {
 	CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);
 	CTeoria* t = (CTeoria*) BRPOINTER(args+1);
-	sa->teorias.add(t->nombre.c_str(), *t);
+	sa->teorias.add(t->nombre, t);
 #ifdef DEBUG
 	std::cout << "Agrega teoria " << t->nombre << ":\n";
 	std::cout << "  .datos_iniciales:\n" << t->datos_iniciales << "\n";
diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp
index 2eeb8dd..7469d10 100644
--- a/trunk/src/sistemaautonomo.cpp
+++ b/trunk/src/sistemaautonomo.cpp
@@ -1,5 +1,6 @@
 
 #include "sistemaautonomo.h"
+#include <sstream>
 
 #ifdef DEBUG
 #include <iostream>
@@ -31,19 +32,20 @@ void CSistemaAutonomo::plan()
 	double p = 1.0;
 	m_plan.clear();
 #ifdef DEBUG
-	std::cout << "entorno:\n" << p_entorno->datos << "\n";
-	std::cout << "datos finales:\n" << m_datos_finales << "\n";
+	std::cout << "SA: Planificando...\n";
+	std::cout << "SA: \tentorno:\n" << p_entorno->datos << "\n";
+	std::cout << "SA: \tdatos finales:\n" << m_datos_finales << "\n";
 #endif // DEBUG
 	planificar(p_entorno->datos, m_datos_finales, m_plan, p);
 #ifdef DEBUG
-	std::cout << "plan:\n" << m_plan << "\n";
+	std::cout << "SA: \tplan:\n" << m_plan << "\n";
 #endif // DEBUG
 	curr_theory = m_plan.begin();
 #ifdef DEBUG
 	if (curr_theory == m_plan.end())
-		std::cout << "No hay teorías\n";
+		std::cout << "SA: No hay teorías\n";
 	else
-		std::cout << "curr teoria: " << &*curr_theory << "=" << curr_theory->nombre << "\n";
+		std::cout << "SA: curr teoria: " << **curr_theory << "\n";
 #endif // DEBUG
 }
 
@@ -65,7 +67,7 @@ CTeoria* CSistemaAutonomo::get_next_theory()
 	}
 	else
 	{
-		return &*(curr_theory++);
+		return *(curr_theory++);
 	}
 }
 
@@ -75,24 +77,35 @@ bool CSistemaAutonomo::validate_theory(CTeoria* t)
 {
 	bool result ;
 
+	// Aumento k (cantidad de veces que se probó la teoría
+	++t->k;
+
+	// Verifico
 	result = verificar_condicion(t->datos_finales) ;
 
+	// Si se ejecuto bien la teoria incremento el p
+	if (result) t->p++ ;
 
 	// Si fallo la teoria
 	if (!result)
 	{
+		// Aplico heuristicas de observacion
+#ifdef DEBUG
+		std::cout << "SA: No verifica, aplicando heuristicas...\n";
+		std::cout << "SA: Aplicando heuristica de observacion\n";
+#endif // DEBUG
+		this->heuristca_observacion(*t) ;
+#ifdef DEBUG
+		std::cout << "SA: Aplicando heuristica de generalizacion\n";
+#endif // DEBUG
+		this->heuristca_generalizacion(*t);
+#ifdef DEBUG
+		std::cout << "SA: Aplicando heuristica de retraccion\n";
+#endif // DEBUG
 		// Aplico heuristicas de correccion
-		this->heurisitca_retraccion(*t) ;
-	}
-	else
-	{
-		t->p++ ;
+		this->heuristca_retraccion(*t) ;
 	}
 
-	// Aplico heuristicas de observacion
-	this->heurisitca_observacion(*t) ;
-	this->heurisitca_generalizacion(*t);
-
 	return result;
 }
 
@@ -104,38 +117,44 @@ bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>&	datos)
 	bool result = true ;
 	unsigned i ;
 
+	for (i = 0; i < datos.count() && result; i++)
+		result = (datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i)));
 
-	for (i=0; i<datos.count() && result; i++)
-		result = datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i))  ;
-
-
-	//
 	return result ;
 }
 
-
+std::string make_nombre(const std::string& n, char mod, unsigned i)
+{
+	std::ostringstream oss;
+	oss << n << "-" << mod << i;
+	return oss.str();
+}
 
 //--------------------------------------------------------------------------------------------
 //--
-void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
+void CSistemaAutonomo::heuristca_observacion(CTeoria& t)
 {
-	CTeoria nt ; //Nueva Teoria
-	unsigned i ;
-	std::string nombre ;
-	
+	CTeoria* pnt = new CTeoria ; //Nueva Teoria
+	CTeoria& nt = *pnt;
+
 	// Le agrego los datos iniciales tal cual estaban antes
-	for (i=0; i<t.datos_iniciales.count(); i++)
-		nt.datos_iniciales.add(t.datos_iniciales.keys(i), t.datos_iniciales[i]) ;
+	nt.datos_iniciales = t.datos_iniciales;
 
 	// Le agrego todas las condiciones del entorno como condicion final
-	for (i=0; i<this->p_entorno->datos.count(); i++)
-		nt.datos_finales.add(this->p_entorno->datos.keys(i), this->p_entorno->datos[i]) ;
+	nt.datos_finales = p_entorno->datos;
 
+	// Le cargo nombre y funcion (queda con k=1 y p=1)
+	nt.nombre = make_nombre(t.nombre, 'o', teorias.count());
+	nt.funcion = t.funcion;
 
 	// Agrego la teoria
-	nombre = teorias.count() ;
-	teorias.add (nombre.c_str(), nt) ;
-	
+	teorias.add (nt.nombre, pnt) ;
+#ifdef DEBUG
+	std::cout << "SA: Se agrego una nueva teoria: " << nt << " basada en " << t << "\n";
+	std::cout << "SA: \tdatos_iniciales:\n" << nt.datos_iniciales << "\n";
+	std::cout << "SA: \tdatos_finales:\n" << nt.datos_finales << "\n";
+#endif // DEBUG
+
 }
 
 //--------------------------------------------------------------------------------------------
@@ -143,9 +162,8 @@ void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
 // Si las condiciones finales del entorno son iguales a las condiciones finales de alguna teoria y
 // solo una condicion inicial es distinta => agrego una nueva teoría igual (a la q cumple los requisitos
 // anteriormente detallados) pero tomando ANY en el valor de entrada en el cual difieren.  
-void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t)
+void CSistemaAutonomo::heuristca_generalizacion(CTeoria& t)
 {
-	CTeoria nt ; //Nueva Teoria
 	unsigned i ;
 	int count = 0;
 	unsigned k = 0;
@@ -156,40 +174,47 @@ void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t)
 
 	cantidadTeorias = this->teorias.count();
 
-	for (i=0; i<cantidadTeorias; i++)
+	for (i = 0; i < cantidadTeorias; i++)
 	{
-		for (k=0; k<this->teorias[i].datos_finales.count(); k++)
+		for (k = 0; k < this->teorias[i]->datos_finales.count(); k++)
 		{
 			//me fijo si las condiciones finales de la teoria se corresponden con la del entorno.
-			if((this->teorias[i].datos_finales[k] != ANY) && (this->p_entorno->datos.find(t.datos_finales.keys(k)) != ANY))
+			if ((this->teorias[i]->datos_finales[k] != ANY) && (this->p_entorno->datos.find(t.datos_finales.keys(k)) != ANY))
 			{
-				if(this->teorias[i].datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k))) 
+				if (this->teorias[i]->datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k))) 
 				{
 					count++;
 				}
 			}
 		}
-		if(count == 0)
+		if (count == 0)
 		{	// si se corresponden (las condiciones finales son iguales) => me fijo si hay alguna condicion inicial q cambia. 
-			for (j=0; j<this->teorias[i].datos_iniciales.count(); j++)
+			for (j = 0; j < this->teorias[i]->datos_iniciales.count(); j++)
 			{
-				if((this->teorias[i].datos_iniciales[j] != ANY) && (this->p_entorno->datos.find(t.datos_iniciales.keys(j)) != ANY))
+				if ((this->teorias[i]->datos_iniciales[j] != ANY) && (this->p_entorno->datos.find(t.datos_iniciales.keys(j)) != ANY))
 				{
-					if(this->teorias[i].datos_iniciales[j] != this->p_entorno->datos.find(t.datos_iniciales.keys(j))) 
+					if (this->teorias[i]->datos_iniciales[j] != this->p_entorno->datos.find(t.datos_iniciales.keys(j))) 
 					{
 						posicionCambio = j;
 						count++;
 					}
 				}
 			}
-			if(count == 1)
-			{//si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia.
-				nt = this->teorias[i];
-				nt.datos_iniciales[posicionCambio] = ANY;
+			if (count == 1)
+			{
+				//si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia.
+				CTeoria* nt = new CTeoria ; //Nueva Teoria
+				*nt = *this->teorias[i];
+				nt->datos_iniciales[posicionCambio] = ANY;
 
 				// Agrego la teoria
-				nombreTeoria = teorias.count() ;
-				teorias.add (nombreTeoria.c_str(), nt) ;
+				nt->nombre = make_nombre(t.nombre, 'g', teorias.count());
+				teorias.add (nt->nombre, nt) ;
+#ifdef DEBUG
+				std::cout << "SA: Se agrego una nueva teoria: " << *nt << " basada en " << *teorias[i] << "\n";
+				std::cout << "SA: \tdatos_iniciales:\n" << nt->datos_iniciales << "\n";
+				std::cout << "SA: \tdatos_finales:\n" << nt->datos_finales << "\n";
+#endif // DEBUG
 			}
 		}
 		posicionCambio = -1;
@@ -199,33 +224,46 @@ void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t)
 
 //--------------------------------------------------------------------------------------------
 //--
-void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
+void CSistemaAutonomo::heuristca_retraccion(CTeoria& t)
 {
-	CTeoria nt ; //Nueva Teoria
 	unsigned i ;
+	unsigned modif = (unsigned)-1;
 
 	// Recorro la condicion final de la teoria
-	for (i=0; i<t.datos_finales.count(); i++)
+	for (i = 0; i < t.datos_finales.count(); i++)
+	{
 		// Si el dato no coincidio con el del entorno, y no era ANY
 		if (t.datos_finales[i] != ANY && 
-			t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
-		   )
+				t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i)))
+		{
 			// Le asigno ANY
 			t.datos_finales[i] = ANY ;
+			modif = i;
+		}
+	}
+	if (modif != (unsigned)-1)
+	{
+		// Le cambio el nombre para indicar que fue modificada
+		t.nombre += "-r";	
+#ifdef DEBUG
+		std::cout << "SA: Se modifica la teoria: " << t << ", el dato final '"
+			<< t.datos_finales.keys(modif) << "' puede tomar ahora cualquier valor\n";
+#endif // DEBUG
+	}
 }
 
 
 //--------------------------------------------------------------------------------------------
 //--
-void CSistemaAutonomo::planificar (	CIndiceMagico<t_dato>&	datos_iniciales,
-									CIndiceMagico<t_dato>&	datos_finales,
-									CIndiceMagico<CTeoria>& plan,
-									double&					p,
-									unsigned long			numero_de_llamada)
+void CSistemaAutonomo::planificar (CIndiceMagico<t_dato>&	datos_iniciales,
+				CIndiceMagico<t_dato>&		datos_finales,
+				CIndiceMagico<CTeoria*>& 	plan,
+				double&				p,
+				unsigned long			numero_de_llamada)
 {
 	unsigned i;
-	CIndiceMagico<CTeoria> test_plan ;
-	CIndiceMagico<CTeoria> new_plan ;
+	CIndiceMagico<CTeoria*> test_plan ;
+	CIndiceMagico<CTeoria*> new_plan ;
 	double test_p ;
 	double max_p = 0 ;
 
@@ -234,18 +272,18 @@ void CSistemaAutonomo::planificar (	CIndiceMagico<t_dato>&	datos_iniciales,
 
 	if ( numero_de_llamada > 7 ) return ;
 
-	for (i=0; i<teorias.count(); i++)
-		if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
+	for (i = 0; i < teorias.count(); i++)
+		if ( incluye_a(teorias[i]->datos_iniciales, datos_iniciales) )
 		{
 			test_plan.clear() ;
-			test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
+			test_plan.add (teorias[i]->nombre, teorias[i]) ;
 
-			test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ;
+			test_p = p * ((double)teorias[i]->p)/((double)teorias[i]->k) ;
 
-			planificar(teorias[i].datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ; 
+			planificar(teorias[i]->datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ; 
 			
 			if ( test_p>max_p )
-			if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
+			if ( incluye_a(test_plan[test_plan.count()-1]->datos_finales, datos_finales) )
 			{
 				max_p = test_p ;
 				new_plan.clear() ;
@@ -290,7 +328,7 @@ bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
 		if (!result)
 		{
 			// Aplico heuristicas de correccion
-			this->heurisitca_retraccion(t) ;
+			this->heuristca_retraccion(t) ;
 		}
 		else
 		{
@@ -298,8 +336,8 @@ bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
 		}
 
 		// Aplico heuristicas de observacion
-		this->heurisitca_observacion(t) ;
-		this->heurisitca_generalizacion(t);
+		this->heuristca_observacion(t) ;
+		this->heuristca_generalizacion(t);
 	}
 
 	//
diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index dd82f82..a7debcd 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:
@@ -83,13 +83,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,6 +125,29 @@ 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.
@@ -138,9 +163,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,7 +205,7 @@ public:
 	CIndiceMagico<t_dato>		m_datos_finales;
 
 	// Las teorias que tiene el SA.
-	CIndiceMagico<CTeoria>		teorias ;
+	CIndiceMagico<CTeoria*>		teorias ;
 
 public:
 	// Constructor
@@ -203,31 +231,31 @@ 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&);
 
 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) ;