#define __SISTEMAAUTONOMO__
#include "indicemagico.h"
+#include <math.h>
+#include <string>
+//#include <map>
+
// DEFINICIONES:
// ------------
class CEntorno ;
+
typedef double t_dato ;
-#define t_fnc(name) double (*name)(CEntorno&)
+#define ANY -3000000
-#define INFINITO 9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long
+//#define t_fnc(name) double (*name)(CEntorno&)
+#define INFINITO 9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long
+
// ------------------------------------------
// Parametros de configuracion de SA
// 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.
-bool cumple_condiciones (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
+bool incluye_a (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
// CTeoria
-template < typename E >
class CTeoria
{
public:
// Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.
// Las condiciones se concatenan con un operador &&
CIndiceMagico<t_dato> datos_iniciales ;
-
+
+ // La funcion que se debe ejecutar para hacer valer la teoria.
+ 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 ;
- // Entorno sobre el cual trabajar
- E& entorno;
-
public:
+ CTeoria()
+ {
+ nombre = "" ;
+ funcion = "" ;
+ k = 1 ;
+ p = 1 ;
+ }
CTeoria(const std::string& ini_nombre,
+ const std::string& ini_funcion,
unsigned long ini_k,
- unsigned long ini_p,
- E& e):
- nombre(ini_nombre),
- k(ini_k),
- p(ini_p),
- entorno(e)
- {}
+ unsigned long ini_p)
+ {
+ nombre = ini_nombre ;
+ funcion = ini_funcion ;
+ k = ini_k ;
+ p = ini_p ;
+ }
- // La funcion que se debe ejecutar para hacer valer la teoria.
- virtual double funcion() = 0;
public:
// Cantidad de veces que se probo la teoria.
unsigned long k ;
-
+
// Cantidad de veces que se probo la teoria y resulto correcta.
unsigned long p ;
CIndiceMagico<t_dato> datos ;
public:
+// CEntorno() { this->inicializar() ; }
+
+public:
+ // Inicializar los datos
+ virtual void inicializar() {} ;
+
// Actualizar los datos
- virtual void actualizar() = 0 ;
+ virtual void actualizar() {} ;
+ // Destructor
virtual ~CEntorno() {}
} ;
// CSistemaAutonomo
-template < typename E >
class CSistemaAutonomo
{
public:
// El entono en el que se mueve el SA.
- E& entorno ;
+ CEntorno* p_entorno ;
+
+ // Datos finales a utilizar al hacer
+ CIndiceMagico<t_dato> m_datos_finales;
// Las teorias que tiene el SA.
- CIndiceMagico< CTeoria< E >* > teorias ;
+ CIndiceMagico<CTeoria> teorias ;
- ~CSistemaAutonomo()
- {
- for (int i = 0; i < teorias.m_cant; ++i)
- {
- delete teorias.m_datos[i];
- }
- }
+public:
+ // Constructor
+ CSistemaAutonomo(): p_entorno(new CEntorno) {}
+ // Destructor
+ ~CSistemaAutonomo() { delete p_entorno; }
-public:
- // Retorna true si los valores de la condicion coinciden con los valores del entorno.
- bool verificar_condicion(CIndiceMagico<t_dato>& datos)
- {
- bool result = true ;
- unsigned i ;
+ // Genera un nuevo plan
+ void plan();
+ // Indica si hay una teoria mas para ejecutar
+ bool has_next_theory();
- for (i=0; i<datos.count() && result; i++)
- result = datos[i] == this->p_entorno->datos.find(datos.keys(i)) ;
+ // 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*) ;
- //
- return result ;
- }
+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< E >&)
- {
- }
+ void heurisitca_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< E >&)
- {
- }
-
-
+ void heurisitca_retraccion(CTeoria&) ;
-protected:
- // Planificador: Se encaga de encontrar una serie de teorias que logren hacer
- // cumplir la condicion_final, partiendo de la condicion_inicial.
- // Parametros:
- // datos_iniciales: Forman la condicion inicial.
- // datos_finales: Forman la condicion final.
- CIndiceMagico<CTeoria< E >* >* planificar (
- CIndiceMagico<t_dato>& datos_iniciales,
- CIndiceMagico<t_dato>& datos_finales,
- CIndiceMagico<CTeoria< E >* >& plan,
- unsigned long numero_de_llamada,
- double& p) ;
+ //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&);
public:
- CSistemaAutonomo(E& e): entorno(e) {}
-
- CIndiceMagico<CTeoria< E >* >* new_plan(CIndiceMagico< t_dato >& datos_finales, double& p)
- {
- CIndiceMagico<CTeoria< E >* > plan ;
- return planificar(entorno.datos, datos_finales, plan, 0, p) ;
- }
+
+ 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< E > >& plan) ;
-
-
+// bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
} ;
-//--------------------------------------------------------------------------------------------
-//-- PROBAR BIEN
-template < typename E >
-CIndiceMagico< CTeoria< E >* >* CSistemaAutonomo< E >::planificar (
- CIndiceMagico< t_dato >& datos_iniciales,
- CIndiceMagico< t_dato >& datos_finales,
- CIndiceMagico< CTeoria< E >* >& plan,
- unsigned long numero_de_llamada,
- double& p)
-{
- unsigned i ;
- double nuevo_p ;
- double max_p = 0 ;
- CIndiceMagico< CTeoria< E >* >* p_nuevo_plan ;
- CIndiceMagico< CTeoria< E >* >* pResult = NULL ;
- CIndiceMagico< CIndiceMagico< CTeoria< E >* > > planes ;
-
-
- for (i=0; i<this->teorias.count(); i++)
- {
- // Si la teoria cumple la condicion inicial
- if ( cumple_condiciones(this->teorias[i]->datos_iniciales, datos_iniciales) )
- {
- p_nuevo_plan = new CIndiceMagico< CTeoria< E >* > ;
-
- nuevo_p = ( p + ((double)this->teorias[i]->p) / ((double)this->teorias[i]->k) ) / 2 ;
-
- // Agrego la teoria al plan
- p_nuevo_plan->add (this->teorias[i]->nombre.c_str(), this->teorias[i]) ;
-
- if (numero_de_llamada<PASOS_MAXIMOS_DE_PLAN)
- {
- // Pero si no cumple con la condicion final
- if ( !cumple_condiciones(datos_finales, this->teorias[i]->datos_finales) )
- {
- planificar (this->teorias[i]->datos_finales,
- datos_finales,
- *p_nuevo_plan,
- numero_de_llamada+1,
- nuevo_p) ;
- }
- }
-
-
- // Si cumple con la condicion final
- if (nuevo_p>max_p)
- {
- if ( cumple_condiciones(datos_finales, (*p_nuevo_plan)[p_nuevo_plan->count()-1]->datos_finales) )
- {
- max_p = nuevo_p ;
-
- if (pResult) delete pResult ;
-
- pResult = p_nuevo_plan ;
- }
- }
- }
- }
-
- //
- return pResult ;
-}
-
-
-//--------------------------------------------------------------------------------------------
-//--
-template < typename E >
-bool CSistemaAutonomo< E >::ejecutar (CIndiceMagico<CTeoria< E > >& plan)
-{
- bool result = true ;
- int i ;
- CTeoria< E > t ;
-
-
- for (i=0; i<plan.count() && result; i++)
- {
- t = plan[i] ;
-
- // Ejecuto la funcion
- t.funcion() ;
-
- // 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) ;
- }
-
- //
- return result ;
-}
-
-
#endif
projects / z.facultad / 75.68 / celdas.git / blobdiff