From 3614a9b0d6ac477997b3b88d7362494e55538dc3 Mon Sep 17 00:00:00 2001 From: Leandro Lucarella Date: Fri, 17 Nov 2006 17:45:29 +0000 Subject: [PATCH] =?utf8?q?Subo=20la=20versi=C3=B3n=201.0.3=20con=20correcc?= =?utf8?q?iones=20para=20que=20compile=20y=20no=20tire=20warnings.?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- trunk/src/Makefile | 15 +++ trunk/src/indicemagico.h | 21 ++- trunk/src/main.cpp | 134 +++++++++++--------- trunk/src/main.h | 38 +++--- trunk/src/sistemaautonomo.cpp | 159 ++++++++++++++++++++++- trunk/src/sistemaautonomo.h | 232 ++++++++-------------------------- 6 files changed, 322 insertions(+), 277 deletions(-) create mode 100644 trunk/src/Makefile diff --git a/trunk/src/Makefile b/trunk/src/Makefile new file mode 100644 index 0000000..42ef74e --- /dev/null +++ b/trunk/src/Makefile @@ -0,0 +1,15 @@ + +CXXFLAGS=-Wall -g + +targets=test + +all: $(targets) +test: main.o sistemaautonomo.o + $(CXX) $(LDFLAGS) -o test *.o + +clean: + $(RM) -fv *.o $(target) + +depend: + makedepend -- $(CFLAGS) -- *.cpp + diff --git a/trunk/src/indicemagico.h b/trunk/src/indicemagico.h index f5a4ac2..4c3396e 100644 --- a/trunk/src/indicemagico.h +++ b/trunk/src/indicemagico.h @@ -8,6 +8,7 @@ #include +#include #include @@ -22,18 +23,16 @@ public: 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 ; + std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres.\n"; if (!m_datos) - cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos." << endl ; + std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos.\n"; } @@ -52,14 +51,14 @@ public: void add(CIndiceMagico& indice) { - for (int i=0; i // -double CMiEntorno::AvanzarX() +double AvanzarX(CEntorno& e) { avanzo_en_x = true ; return 0 ; } -double CMiEntorno::AvanzarY() +double AvanzarY(CEntorno& e) { avanzo_en_y = true ; return 0 ; } -double CMiEntorno::AvanzarZ() +double AvanzarZ(CEntorno& e) { avanzo_en_z = true ; return 0 ; } -CMiEntorno::CMiEntorno(): - avanzo_en_x(true), avanzo_en_y(true), avanzo_en_z(true) +// +void CMiEntorno::inicializar() { // 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.avanzo_en_x", 0) ; + datos.add("robot.avanzo_en_y", 0) ; + datos.add("robot.avanzo_en_z", 0) ; datos.add("robot.sensor_1", 0) ; datos.add("robot.sensor_2", 0) ; @@ -49,76 +51,84 @@ void CMiEntorno::actualizar() } -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) ; + CMiEntorno e ; + CSistemaAutonomo a ; + e.inicializar() ; // Inicializo las teorias - a.teorias.add("teoria1", new CMiTeoria1(e)) ; - a.teorias.add("teoria2", new CMiTeoria2(e)) ; - a.teorias.add("teoria3", new CMiTeoria3(e)) ; + CTeoria t1("Avanzar_X_1", &AvanzarX, 1, 1) ; + t1.datos_iniciales.add ("robot.sensor_1", 0) ; + t1.datos_iniciales.add ("robot.sensor_2", ANY) ; + t1.datos_iniciales.add ("robot.sensor_3", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_en_x", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_en_y", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_en_z", ANY) ; + t1.datos_finales.add ("robot.avanzo_en_x", 1) ; + t1.datos_finales.add ("robot.avanzo_en_y", 0) ; + t1.datos_finales.add ("robot.avanzo_en_z", 0) ; + t1.datos_finales.add ("robot.sensor_1", ANY) ; + t1.datos_finales.add ("robot.sensor_2", ANY) ; + t1.datos_finales.add ("robot.sensor_3", ANY) ; + + CTeoria t2("Avanzar_Y_1", &AvanzarY, 1, 1) ; + t2.datos_iniciales.add ("robot.sensor_1", ANY) ; + t2.datos_iniciales.add ("robot.sensor_2", 0) ; + t2.datos_iniciales.add ("robot.sensor_3", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_en_x", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_en_y", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_en_z", ANY) ; + t2.datos_finales.add ("robot.avanzo_en_x", 0) ; + t2.datos_finales.add ("robot.avanzo_en_y", 1) ; + t2.datos_finales.add ("robot.avanzo_en_z", 0) ; + t2.datos_finales.add ("robot.sensor_1", ANY) ; + t2.datos_finales.add ("robot.sensor_2", ANY) ; + t2.datos_finales.add ("robot.sensor_3", ANY) ; + + CTeoria t3("Avanzar_Z_1", &AvanzarZ, 1, 1) ; + t3.datos_iniciales.add ("robot.sensor_1", ANY) ; + t3.datos_iniciales.add ("robot.sensor_2", ANY) ; + t3.datos_iniciales.add ("robot.sensor_3", 0) ; + t3.datos_iniciales.add ("robot.avanzo_en_x", ANY) ; + t3.datos_iniciales.add ("robot.avanzo_en_y", ANY) ; + t3.datos_iniciales.add ("robot.avanzo_en_z", ANY) ; + t3.datos_finales.add ("robot.avanzo_en_x", 0) ; + t3.datos_finales.add ("robot.avanzo_en_y", 0) ; + t3.datos_finales.add ("robot.avanzo_en_z", 1) ; + t3.datos_finales.add ("robot.sensor_1", ANY) ; + t3.datos_finales.add ("robot.sensor_2", ANY) ; + t3.datos_finales.add ("robot.sensor_3", ANY) ; + + a.teorias.add(t1.nombre.c_str(), t1) ; + a.teorias.add(t2.nombre.c_str(), t2) ; + a.teorias.add(t3.nombre.c_str(), t3) ; + + + // Inicializo el SA + a.p_entorno = (CEntorno*)(&e) ; // Obtengo un plan double p = 1 ; - CIndiceMagico* >* p_plan ; + CIndiceMagico plan ; CIndiceMagico datos_finales ; + + datos_finales.add ("robot.avanzo_en_y", 1) ; + + a.planificar (a.p_entorno->datos, datos_finales, plan, p) ; - datos_finales.add ("robot.avanzo_en_x", 1) ; + for (unsigned i=0; icount(); i++) - std::cout << (*p_plan)[i]->nombre << std::endl ; + // Ejecuto el plan + a.ejecutar(plan) ; return 0 ; diff --git a/trunk/src/main.h b/trunk/src/main.h index 1c551bd..5cbb72f 100644 --- a/trunk/src/main.h +++ b/trunk/src/main.h @@ -1,29 +1,31 @@ + #include "sistemaautonomo.h" -// Entono especializado -struct CMiEntorno : CEntorno -{ -public: - // Variables que definien el entorno REAL - double sensor_1 ; - double sensor_2 ; - double sensor_3 ; +// Variables que definien el entorno REAL +static double sensor_1 = 0 ; +static double sensor_2 = 0 ; +static double sensor_3 = 0 ; - bool avanzo_en_x ; - bool avanzo_en_y ; - bool avanzo_en_z ; +static bool avanzo_en_x = false ; +static bool avanzo_en_y = false ; +static bool avanzo_en_z = false ; - CMiEntorno() ; - virtual void actualizar() ; - // Funciones que usa el SA para modificar el entorno - double AvanzarX(); - double AvanzarY(); - double AvanzarZ(); +// Funciones que usa el SA para modificar el entorno +double AcanzarX(CEntorno& e); +double AcanzarY(CEntorno& e); +double AcanzarZ(CEntorno& e); + + +// Entono especializado +class CMiEntorno : CEntorno +{ +public: + virtual void inicializar() ; + virtual void actualizar() ; } ; // Main int main(int, char**) ; - diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp index f4cbbab..5f1cf2c 100644 --- a/trunk/src/sistemaautonomo.cpp +++ b/trunk/src/sistemaautonomo.cpp @@ -4,19 +4,170 @@ //-------------------------------------------------------------------------------------------- //-- Funciones Auxiliares +bool incluye_a (CIndiceMagico& a, CIndiceMagico& b) +{ + bool result = true ; + unsigned i ; + // Todas las variables de la condicion b deben estar en la condicion a + for (i=0; i& muestra, CIndiceMagico& patron) -{ + +//-------------------------------------------------------------------------------------------- +//-- +bool CSistemaAutonomo::verificar_condicion(CIndiceMagico& datos) +{ bool result = true ; unsigned i ; - for (i=0; ip_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; ip_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) ; + } + +//-------------------------------------------------------------------------------------------- +//-- +void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t) +{ + CTeoria nt ; //Nueva Teoria + unsigned i ; + + // Recorro la condicion final de la teoria + for (i=0; ip_entorno->datos.find(t.datos_finales.keys(i)) + ) + // Le asigno ANY + t.datos_finales[i] = ANY ; +} + + +//-------------------------------------------------------------------------------------------- +//-- +void CSistemaAutonomo::planificar ( CIndiceMagico& datos_iniciales, + CIndiceMagico& datos_finales, + CIndiceMagico& plan, + double& p, + unsigned long numero_de_llamada) +{ + unsigned i; + CIndiceMagico test_plan ; + CIndiceMagico 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; imax_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& plan) +{ + bool result = true ; + unsigned i ; + t_fnc(pFnc) ; + CTeoria t ; + + + for (i=0; ip_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) ; + } + + // + return result ; +} diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h index d0355fd..a5e71c4 100644 --- a/trunk/src/sistemaautonomo.h +++ b/trunk/src/sistemaautonomo.h @@ -3,6 +3,10 @@ #define __SISTEMAAUTONOMO__ #include "indicemagico.h" +#include +#include +//#include + // DEFINICIONES: // ------------ @@ -21,14 +25,17 @@ class CEntorno ; + typedef double t_dato ; +#define ANY -3000000 + + #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 @@ -72,13 +79,12 @@ typedef double t_dato ; -bool cumple_condiciones (CIndiceMagico&, CIndiceMagico&) ; +bool incluye_a (CIndiceMagico&, CIndiceMagico&) ; // CTeoria -template < typename E > class CTeoria { public: @@ -89,32 +95,38 @@ 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 datos_iniciales ; - + + // La funcion que se debe ejecutar para hacer valer la teoria. + double (*funcion)(CEntorno& e) ; + // Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial CIndiceMagico datos_finales ; - // Entorno sobre el cual trabajar - E& entorno; - public: + CTeoria() + { + nombre = "" ; + funcion = NULL ; + k = 1 ; + p = 1 ; + } - CTeoria(const std::string& ini_nombre, + CTeoria(const char* ini_nombre, + double (*ini_funcion)(CEntorno& e), 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 ; @@ -133,209 +145,65 @@ public: CIndiceMagico 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 ; // 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]; - } - } - + CIndiceMagico teorias ; public: // Retorna true si los valores de la condicion coinciden con los valores del entorno. - bool verificar_condicion(CIndiceMagico& datos) - { - bool result = true ; - unsigned i ; - - - for (i=0; ip_entorno->datos.find(datos.keys(i)) ; - - - // - return result ; - } + bool verificar_condicion(CIndiceMagico& datos) ; 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* >* planificar ( - CIndiceMagico& datos_iniciales, - CIndiceMagico& datos_finales, - CIndiceMagico* >& plan, - unsigned long numero_de_llamada, - double& p) ; - public: - CSistemaAutonomo(E& e): entorno(e) {} - - CIndiceMagico* >* new_plan(CIndiceMagico< t_dato >& datos_finales, double& p) - { - CIndiceMagico* > plan ; - return planificar(entorno.datos, datos_finales, plan, 0, p) ; - } + + void planificar ( CIndiceMagico& datos_iniciales, + CIndiceMagico& datos_finales, + CIndiceMagico& 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 >& plan) ; + bool ejecutar (CIndiceMagico& 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; iteorias.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_llamadateorias[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 >& plan) -{ - bool result = true ; - int i ; - CTeoria< E > t ; - - - for (i=0; ip_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 -- 2.43.0