X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/3614a9b0d6ac477997b3b88d7362494e55538dc3..2a0c7d1e56dfff663c1fbcaaf39b4e00140a0121:/trunk/src/sistemaautonomo.h

diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h
index a5e71c4..4aafef5 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:
@@ -30,7 +30,7 @@ typedef double t_dato ;
 #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
@@ -44,7 +44,7 @@ typedef double t_dato ;
 
 // 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.
@@ -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.
@@ -97,7 +99,8 @@ public:
 	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
 	CIndiceMagico<t_dato>	datos_finales ;
@@ -106,13 +109,13 @@ public:
 	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)
 	{
@@ -122,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.
@@ -136,6 +162,14 @@ public:
 
 } ;
 
+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
@@ -165,42 +199,75 @@ class CSistemaAutonomo
 {
 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 ;
 
 public:
+	// Constructor
+	CSistemaAutonomo(): p_entorno(new CEntorno) {}
+
+	// Destructor
+	~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 heuristca_generalizacion(CTeoria&);
 
 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) ;
 } ;