X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/44029734cc5263d0548dc78ce9d71c43719d1ea7..b46d26ffabbc1b3c480293a458f73daad3017443:/trunk/src/sistemaautonomo.cpp

diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp
index f4cbbab..0efe70a 100644
--- a/trunk/src/sistemaautonomo.cpp
+++ b/trunk/src/sistemaautonomo.cpp
@@ -4,19 +4,289 @@
 
 //--------------------------------------------------------------------------------------------
 //-- Funciones Auxiliares
+bool incluye_a (CIndiceMagico<t_dato>& a, CIndiceMagico<t_dato>& b) 
+{
+	bool result = true ;
+	unsigned i ;
 
+	// Todas las variables de la condicion b deben estar en la condicion a
+	for (i=0; i<b.count() && result; i++)
+		result=a.exist(b.keys(i)) ;
 
-bool cumple_condiciones (CIndiceMagico<t_dato>& muestra, CIndiceMagico<t_dato>& patron) 
+	// Todas las variables de la condicion a deben tener el mismo valor que en la condicion b
+	for (i=0; i<b.count() && result; i++)
+		result = b[i] == a.find(b.keys(i)) || b[i] == ANY || a.find(b.keys(i)) == ANY  ;
+	//
+	return result ;
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::plan()
 {
+	double p = 1.0;
+	m_plan.clear();
+	planificar(p_entorno->datos, m_datos_finales, m_plan, p);
+	curr_theory = m_plan.begin();
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+#include <iostream> // XXX FIXME
+bool CSistemaAutonomo::has_next_theory()
+{
+	return curr_theory != m_plan.end();
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+CTeoria* CSistemaAutonomo::get_next_theory()
+{
+	if (curr_theory == m_plan.end())
+	{
+		m_datos_finales.clear();
+		return 0;
+	}
+	else
+	{
+		return &*(curr_theory++);
+	}
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::validate_theory(CTeoria* t)
+{
+	bool result ;
+
+	result = verificar_condicion(t->datos_finales) ;
 
+
+	// Si fallo la teoria
+	if (!result)
+	{
+		// Aplico heuristicas de correccion
+		this->heurisitca_retraccion(*t) ;
+	}
+	else
+	{
+		t->p++ ;
+	}
+
+	// Aplico heuristicas de observacion
+	this->heurisitca_observacion(*t) ;
+	this->heurisitca_generalizacion(*t);
+
+	return result;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>&	datos)
+{
 	bool result = true ;
 	unsigned i ;
 
-	for (i=0; i<muestra.count() && result; i++)
-		result = (muestra[i] == patron.find(muestra.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 ;
+}
 
+
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
+{
+	CTeoria nt ; //Nueva Teoria
+	unsigned i ;
+	std::string nombre ;
+	
+	// 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]) ;
+
+	// 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]) ;
+
+
+	// Agrego la teoria
+	nombre = teorias.count() ;
+	teorias.add (nombre.c_str(), nt) ;
+	
 }
 
+//--------------------------------------------------------------------------------------------
+//--
+// 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)
+{
+	CTeoria nt ; //Nueva Teoria
+	unsigned i ;
+	int count = 0;
+	unsigned k = 0;
+	unsigned j = 0;
+	int posicionCambio = -1;
+	unsigned cantidadTeorias = 0;
+	std::string nombreTeoria;
+
+	cantidadTeorias = this->teorias.count();
+
+	for (i=0; i<cantidadTeorias; i++)
+	{
+		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] != this->p_entorno->datos.find(t.datos_finales.keys(k))) 
+				{
+					count++;
+				}
+			}
+		}
+		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++)
+			{
+				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))) 
+					{
+						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;
+
+				// Agrego la teoria
+				nombreTeoria = teorias.count() ;
+				teorias.add (nombreTeoria.c_str(), nt) ;
+			}
+		}
+		posicionCambio = -1;
+		count = 0;
+	}
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
+{
+	CTeoria nt ; //Nueva Teoria
+	unsigned i ;
+
+	// Recorro la condicion final de la teoria
+	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))
+		   )
+			// Le asigno ANY
+			t.datos_finales[i] = ANY ;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+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 ;
+	double test_p ;
+	double max_p = 0 ;
+
+
+	if ( incluye_a(datos_iniciales, datos_finales) ) return ;
+
+	if ( numero_de_llamada > 7 ) return ;
+
+	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_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) ; 
+			
+			if ( test_p>max_p )
+			if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
+			{
+				max_p = test_p ;
+				new_plan.clear() ;
+				new_plan.add (test_plan) ;
+			}
+		}
+
+	if (max_p>0)
+		plan.add (new_plan) ;
+}
+
+
+/*
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
+{
+	bool result = true ;
+	unsigned i ;
+	t_fnc(pFnc) ;
+	CTeoria t ;	
+
+
+	for (i=0; i<plan.count() && result; i++)
+	{
+		t = plan[i] ;
+		pFnc = t.funcion;
+
+		// Ejecuto la funcion
+		(*pFnc)(*(this->p_entorno)) ;
+
+		// Incremento el K
+		t.k++ ;
+
+		// Actualizo los datos del entorno
+		this->p_entorno->actualizar() ;
+
+		// Veo si se verifica la condicion final
+		result = this->verificar_condicion(t.datos_finales) ;
+
+		// Si fallo la teoria
+		if (!result)
+		{
+			// Aplico heuristicas de correccion
+			this->heurisitca_retraccion(t) ;
+		}
+		else
+		{
+			t.p++ ;
+		}
+
+		// Aplico heuristicas de observacion
+		this->heurisitca_observacion(t) ;
+		this->heurisitca_generalizacion(t);
+	}
+
+	//
+	return result ;
+}
+*/