--- /dev/null
+
+
+#ifndef __INDICEMAGICO__
+#define __INDICEMAGICO__
+
+#define MAX_ELEMENTOS 500
+
+
+
+#include <string>
+#include <iostream>
+
+
+template <class T>
+class CIndiceMagico
+{
+public:
+ std::string* m_nombres ;
+ T* m_datos ;
+ unsigned m_cant ;
+
+public:
+ CIndiceMagico()
+ {
+ using std::cerr;
+ using std::endl;
+ m_cant = 0 ;
+ m_nombres = (std::string*)calloc(sizeof(std::string), MAX_ELEMENTOS) ;
+ m_datos = (T*)calloc(sizeof(m_datos), MAX_ELEMENTOS) ;
+
+
+ if (!m_nombres)
+ cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres." << endl ;
+
+ if (!m_datos)
+ cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos." << endl ;
+
+ }
+
+public:
+ void add(const char* nombre, const T dato)
+ {
+ //Si ya existÃa, lo borro
+ if (exist(nombre))
+ remove(nombre) ;
+
+
+ m_nombres[m_cant] = nombre ;
+ m_datos[m_cant++] = dato ;
+ }
+
+
+ void add(CIndiceMagico<T>& indice)
+ {
+ for (int i=0; i<indice.m_cant; i++)
+ add(indice.m_nombres[i], indice.m_datos[i]) ;
+ }
+
+
+ bool exist(const char* nombre)
+ {
+ for (int i=0; i<m_cant; i++)
+ if (m_nombres[i]==nombre)
+ return true ;
+
+ return false ;
+ }
+
+ //PRE: Existe un elemento con la clave <nombre>.
+ //POS: Retorna el elemento.
+ T& find(const char* nombre)
+ {
+ int i;
+ for (i=0; i<m_cant && m_nombres[i]!=nombre; i++) ;
+ return m_datos[i] ;
+ }
+
+
+ void set_val(const std::string nombre, T valor)
+ {
+ for (int i=0; i<m_cant; i++)
+ if (m_datos[i]!=valor)
+ m_datos[i] ;
+ }
+
+
+ void clear()
+ {
+ m_cant = 0 ;
+ }
+
+ void remove(const unsigned long index)
+ {
+ for (int i=index+1; i<m_cant; i++)
+ {
+ m_nombres[i-1] = m_nombres[i] ;
+ m_datos[i-1] = m_datos[i] ;
+ }
+
+ m_cant-- ;
+ }
+
+ void remove(const char* nombre)
+ {
+ bool exito = false ;
+ int i;
+
+ for (i=0; !exito && i<m_cant; i++)
+ exito = m_nombres[i]==nombre ;
+
+ if (exito)
+ remove(i) ;
+ }
+
+ T& operator [] (unsigned i) { return m_datos[i]; }
+
+ T& items (unsigned i) { return m_datos[i]; }
+
+ char* keys (unsigned i) const { return (char*)(m_nombres[i].c_str()); }
+
+ unsigned count() { return m_cant ; }
+
+} ;
+
+
+
+#endif
--- /dev/null
+#include "main.h"
+
+//
+double CMiEntorno::AvanzarX()
+{
+ avanzo_en_x = true ;
+ return 0 ;
+}
+
+
+double CMiEntorno::AvanzarY()
+{
+ avanzo_en_y = true ;
+ return 0 ;
+}
+
+
+double CMiEntorno::AvanzarZ()
+{
+ avanzo_en_z = true ;
+ return 0 ;
+}
+
+
+CMiEntorno::CMiEntorno():
+ avanzo_en_x(true), avanzo_en_y(true), avanzo_en_z(true)
+{
+ // Inicializo el Entorno
+ datos.add("robot.avanzo_en_x", 1) ;
+ datos.add("robot.avanzo_en_y", 1) ;
+ datos.add("robot.avanzo_en_z", 1) ;
+
+ datos.add("robot.sensor_1", 0) ;
+ datos.add("robot.sensor_2", 0) ;
+ datos.add("robot.sensor_3", 0) ;
+}
+
+
+void CMiEntorno::actualizar()
+{
+ datos.find("robot.sensor_1") = sensor_1 ;
+ datos.find("robot.sensor_2") = sensor_2 ;
+ datos.find("robot.sensor_3") = sensor_3 ;
+
+ 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 ;
+
+
+}
+
+struct CMiTeoria1: CTeoria< CMiEntorno >
+{
+ CMiTeoria1(CMiEntorno& e):
+ CTeoria< CMiEntorno >("Avanzar_X_1", 1, 1, e)
+ {
+ datos_iniciales.add ("robot.sensor_1", 0) ;
+ datos_finales.add ("robot.avanzo_en_x", 1) ;
+ }
+ double funcion()
+ {
+ entorno.avanzo_en_x = true ;
+ return 0 ;
+ }
+};
+
+struct CMiTeoria2: CTeoria< CMiEntorno >
+{
+ CMiTeoria2(CMiEntorno& e):
+ CTeoria< CMiEntorno >("Avanzar_Y_1", 1, 1, e)
+ {
+ datos_iniciales.add ("robot.sensor_2", 0) ;
+ datos_finales.add ("robot.avanzo_en_y", 1) ;
+ }
+ double funcion()
+ {
+ entorno.avanzo_en_y = true ;
+ return 0 ;
+ }
+};
+
+struct CMiTeoria3: CTeoria< CMiEntorno >
+{
+ CMiTeoria3(CMiEntorno& e):
+ CTeoria< CMiEntorno >("Avanzar_Z_1", 1, 1, e)
+ {
+ datos_iniciales.add ("robot.sensor_3", 0) ;
+ datos_finales.add ("robot.avanzo_en_z", 1) ;
+ }
+ double funcion()
+ {
+ entorno.avanzo_en_z = true ;
+ return 0 ;
+ }
+};
+
+//
+int main(int argc, char** argv)
+{
+ //
+ CMiEntorno e ;
+ CSistemaAutonomo< CMiEntorno > a(e) ;
+
+
+ // Inicializo las teorias
+ a.teorias.add("teoria1", new CMiTeoria1(e)) ;
+ a.teorias.add("teoria2", new CMiTeoria2(e)) ;
+ a.teorias.add("teoria3", new CMiTeoria3(e)) ;
+
+
+ // Obtengo un plan
+ double p = 1 ;
+ CIndiceMagico<CTeoria< CMiEntorno >* >* p_plan ;
+ CIndiceMagico<t_dato> datos_finales ;
+
+ datos_finales.add ("robot.avanzo_en_x", 1) ;
+
+ p_plan = a.new_plan(datos_finales, p) ;
+
+ for (int i=0; i<p_plan->count(); i++)
+ std::cout << (*p_plan)[i]->nombre << std::endl ;
+
+
+ return 0 ;
+}
+
+
--- /dev/null
+
+#ifndef __SISTEMAAUTONOMO__
+#define __SISTEMAAUTONOMO__
+
+#include "indicemagico.h"
+
+// DEFINICIONES:
+// ------------
+//
+// ENTORNO: Variables que definen el entorno.
+// CONDICION va=a AND vb=b AND vc=c.
+// TEORIA: Se cumple condicion_inicial y ejecuto funcion F, entonces se cumplira condicion_final.
+// SISTEMA AUTONOMO: Tiene un ENTORNO y una cantidad de TEORIAS.
+// CICLO: Son los pasos de:
+// * Tomar los valores el entorno.
+// * Decidir una condicion que deberia cumplir el entorno.
+// * Planificar (PLAN) una serie de acciones (PASOS) para alcanzar la condicion deseada.
+// * Ejecutar el plan, verificando en cada paso que se vayan cumpliendo las teorias intermedias.
+// PLAN:
+// PASO:
+
+class CEntorno ;
+
+typedef double t_dato ;
+#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
+
+
+// [Ejecutador]
+
+// Precision en la comparacion de atributos.
+// Poner en 0 si se quiere hacer la comparacion exacta.
+#define PRECISION 0.50000
+
+// 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.
+// Esto permite generar nuevas teorias, pero quita performance al proceso de ejecucion.
+//#define VERIFICAL_RESULTADOS_EN_CADA_PASO true
+
+
+// [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.
+// Este valor es un compromiso entre performance y eficiencia.
+// Poner INFINITO si se desea deshabilitar esta opcion.
+#define PLANES_MAXIMOS_TESTEADOS 10
+
+// Es la minima relacion P/K que puede tener una teoria para considerarse como aceptable.
+#define TOLERANCIA 0.75
+
+
+// [Heuristicas]
+
+// Cantidad de ciclos que se recuerda una teoria.
+// Poner INFINITO si se desea deshabilitar esta opcion.
+#define CICLOS_DE_MEMORIA 10
+
+
+
+
+bool cumple_condiciones (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
+
+
+
+
+// CTeoria
+template < typename E >
+class CTeoria
+{
+public:
+
+ std::string nombre ;
+
+ // Condiciones iniciales de la teoria.
+ // 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 ;
+
+ // 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(const std::string& ini_nombre,
+ unsigned long ini_k,
+ unsigned long ini_p,
+ E& e):
+ nombre(ini_nombre),
+ k(ini_k),
+ p(ini_p),
+ entorno(e)
+ {}
+
+ // 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 ;
+
+ // Cantidad de ciclos ocurridos desde que se creo la teoria.
+ // Este parametro se usa para quitarle memoria al SA.
+ unsigned long ciclos ;
+
+} ;
+
+
+
+// CEntorno
+class CEntorno
+{
+public:
+ CIndiceMagico<t_dato> datos ;
+
+public:
+ // Actualizar los datos
+ virtual void actualizar() = 0 ;
+
+ virtual ~CEntorno() {}
+} ;
+
+
+
+// CSistemaAutonomo
+template < typename E >
+class CSistemaAutonomo
+{
+public:
+ // El entono en el que se mueve el SA.
+ E& entorno ;
+
+ // Las teorias que tiene el SA.
+ CIndiceMagico< CTeoria< E >* > teorias ;
+
+ ~CSistemaAutonomo()
+ {
+ for (int i = 0; i < teorias.m_cant; ++i)
+ {
+ delete teorias.m_datos[i];
+ }
+ }
+
+
+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 ;
+
+
+ for (i=0; i<datos.count() && result; i++)
+ result = datos[i] == this->p_entorno->datos.find(datos.keys(i)) ;
+
+
+ //
+ return result ;
+ }
+
+
+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 >&)
+ {
+ }
+
+ // 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 >&)
+ {
+ }
+
+
+
+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) ;
+
+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) ;
+ }
+
+
+ // Ejecuta una serie de pasos.
+ // Retorna true si se alcanza la condicion final.
+ bool ejecutar (CIndiceMagico<CTeoria< E > >& 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 / commitdiff