From 651df9d4bd2ec484ec71c80d7dd2165d7cf4290e Mon Sep 17 00:00:00 2001 From: Leandro Lucarella Date: Sat, 16 Dec 2006 17:07:28 +0000 Subject: [PATCH] =?utf8?q?Bugfixes=20varios.=20Lo=20m=C3=A1s=20importante?= =?utf8?q?=20es=20que=20ahora=20se=20almacenan=20las=20teor=C3=ADas=20en?= =?utf8?q?=20los=20planes=20(y=20en=20el=20sistema=20aut=C3=B3nomo)=20como?= =?utf8?q?=20punteros=20en=20vez=20de=20copias.=20Las=20copias=20produc?= =?utf8?q?=C3=ADan=20grandes=20problemas=20de=20performance=20y=20lo=20que?= =?utf8?q?=20es=20peor,=20que=20no=20permit=C3=ADan=20que=20algunas=20heur?= =?utf8?q?=C3=ADsticas=20tengan=20efecto=20porque=20se=20modificaban=20las?= =?utf8?q?=20copias=20en=20vez=20de=20los=20originales.?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Haciendo pruebas básicas parece que ahora el sistema autónomo anda jamón =) --- trunk/src/main.cpp | 163 +++++++++++++++++++++++++++---- trunk/src/main.h | 3 +- trunk/src/plugin.cpp | 2 +- trunk/src/sistemaautonomo.cpp | 178 +++++++++++++++++++++------------- trunk/src/sistemaautonomo.h | 50 +++++++--- 5 files changed, 292 insertions(+), 104 deletions(-) diff --git a/trunk/src/main.cpp b/trunk/src/main.cpp index 3076aa1..ea0826e 100644 --- a/trunk/src/main.cpp +++ b/trunk/src/main.cpp @@ -5,6 +5,16 @@ // void CMiEntorno::inicializar() { + // Inicializo el Entorno + datos.add("robot.sensor_adelante", 1) ; + datos.add("robot.sensor_atras", 0) ; + datos.add("robot.sensor_derecha", 0) ; + datos.add("robot.sensor_izquierda", 0) ; + datos.add("robot.avanzo_adelante", 0) ; + datos.add("robot.avanzo_atras", 0) ; + datos.add("robot.avanzo_derecha", 0) ; + datos.add("robot.avanzo_izquierda", 0) ; +/* // Inicializo el Entorno datos.add("robot.avanzo_en_x", 0) ; // old datos.add("robot.avanzo_en_y", 0) ; @@ -14,11 +24,22 @@ void CMiEntorno::inicializar() datos.add("robot.sensor_2", 0) ; datos.add("robot.sensor_3", 0) ; datos.add("robot.sensor_4", 0) ; // new +*/ } void CMiEntorno::actualizar() { + datos.find("robot.avanzo_adelante") = 0 ; + datos.find("robot.avanzo_atras") = 0 ; + datos.find("robot.avanzo_derecha") = 0 ; + datos.find("robot.avanzo_izquierda") = 0 ; + datos.find("robot.sensor_adelante") = 0 ; + datos.find("robot.sensor_atras") = 0 ; + datos.find("robot.sensor_derecha") = 0 ; + datos.find("robot.sensor_izquierda") = 0 ; + +/* datos.find("robot.sensor_1") = sensor_1 ; datos.find("robot.sensor_2") = sensor_2 ; datos.find("robot.sensor_3") = sensor_3 ; @@ -27,7 +48,7 @@ void CMiEntorno::actualizar() 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 ; - +*/ } @@ -87,6 +108,7 @@ int main(int argc, char* argv[]) t3.datos_finales.add ("robot.sensor_3", ANY) ; */ +/* // Inicializo las teorias CTeoria t1("Avanzar_X_1", "AvanzarX", 1, 1) ; t1.datos_iniciales.add ("robot.sensor_1", ANY) ; @@ -113,6 +135,7 @@ int main(int argc, char* argv[]) t2.datos_finales.add ("robot.sensor_3", ANY) ; t2.datos_finales.add ("robot.sensor_4", ANY) ; + a.teorias.add(t1.nombre.c_str(), t1) ; a.teorias.add(t2.nombre.c_str(), t2) ; // OLD a.teorias.add(t3.nombre.c_str(), t3) ; @@ -125,38 +148,136 @@ int main(int argc, char* argv[]) std::cout << " .datos_finales:\n" << t2.datos_finales << "\n"; #endif // DEBUG - +*/ + + // Inicializo las teorias + CTeoria t1("Avanzar", "avanzar", 1, 1) ; + t1.datos_iniciales.add ("robot.sensor_adelante", 0) ; + t1.datos_iniciales.add ("robot.sensor_atras", ANY) ; + t1.datos_iniciales.add ("robot.sensor_derecha", ANY) ; + t1.datos_iniciales.add ("robot.sensor_izquierda", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_adelante", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_atras", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_derecha", ANY) ; + t1.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ; + t1.datos_finales.add ("robot.sensor_adelante", ANY) ; + t1.datos_finales.add ("robot.sensor_atras", ANY) ; + t1.datos_finales.add ("robot.sensor_derecha", ANY) ; + t1.datos_finales.add ("robot.sensor_izquierda", ANY) ; + t1.datos_finales.add ("robot.avanzo_adelante", 1) ; + t1.datos_finales.add ("robot.avanzo_atras", 0) ; + t1.datos_finales.add ("robot.avanzo_derecha", 0) ; + t1.datos_finales.add ("robot.avanzo_izquierda", 0) ; + + + CTeoria t2("Retroceder", "retroceder", 1, 1) ; + t2.datos_iniciales.add ("robot.sensor_adelante", ANY) ; + t2.datos_iniciales.add ("robot.sensor_atras", 0) ; + t2.datos_iniciales.add ("robot.sensor_derecha", ANY) ; + t2.datos_iniciales.add ("robot.sensor_izquierda", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_adelante", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_atras", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_derecha", ANY) ; + t2.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ; + t2.datos_finales.add ("robot.sensor_adelante", ANY) ; + t2.datos_finales.add ("robot.sensor_atras", ANY) ; + t2.datos_finales.add ("robot.sensor_derecha", ANY) ; + t2.datos_finales.add ("robot.sensor_izquierda", ANY) ; + t2.datos_finales.add ("robot.avanzo_adelante", 0) ; + t2.datos_finales.add ("robot.avanzo_atras", 1) ; + t2.datos_finales.add ("robot.avanzo_derecha", 0) ; + t2.datos_finales.add ("robot.avanzo_izquierda", 0) ; + + + CTeoria t3("Derecha", "derecha", 1, 1) ; + t3.datos_iniciales.add ("robot.sensor_adelante", ANY) ; + t3.datos_iniciales.add ("robot.sensor_atras", ANY) ; + t3.datos_iniciales.add ("robot.sensor_derecha", 0) ; + t3.datos_iniciales.add ("robot.sensor_izquierda", ANY) ; + t3.datos_iniciales.add ("robot.avanzo_adelante", ANY) ; + t3.datos_iniciales.add ("robot.avanzo_atras", ANY) ; + t3.datos_iniciales.add ("robot.avanzo_derecha", ANY) ; + t3.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ; + t3.datos_finales.add ("robot.sensor_adelante", ANY) ; + t3.datos_finales.add ("robot.sensor_atras", ANY) ; + t3.datos_finales.add ("robot.sensor_derecha", ANY) ; + t3.datos_finales.add ("robot.sensor_izquierda", ANY) ; + t3.datos_finales.add ("robot.avanzo_adelante", 0) ; + t3.datos_finales.add ("robot.avanzo_atras", 0) ; + t3.datos_finales.add ("robot.avanzo_derecha", 1) ; + t3.datos_finales.add ("robot.avanzo_izquierda", 0) ; + + + CTeoria t4("Eludir.1", "derecha", 1, 1) ; + t4.datos_iniciales.add ("robot.sensor_adelante", 1) ; + t4.datos_iniciales.add ("robot.sensor_atras", ANY) ; + t4.datos_iniciales.add ("robot.sensor_derecha", 0) ; + t4.datos_iniciales.add ("robot.sensor_izquierda", ANY) ; + t4.datos_iniciales.add ("robot.avanzo_adelante", ANY) ; + t4.datos_iniciales.add ("robot.avanzo_atras", ANY) ; + t4.datos_iniciales.add ("robot.avanzo_derecha", ANY) ; + t4.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ; + t4.datos_finales.add ("robot.sensor_adelante", 0) ; + t4.datos_finales.add ("robot.sensor_atras", ANY) ; + t4.datos_finales.add ("robot.sensor_derecha", ANY) ; + t4.datos_finales.add ("robot.sensor_izquierda", ANY) ; + t4.datos_finales.add ("robot.avanzo_adelante", 0) ; + t4.datos_finales.add ("robot.avanzo_atras", ANY) ; + t4.datos_finales.add ("robot.avanzo_derecha", 1) ; + t4.datos_finales.add ("robot.avanzo_izquierda", ANY) ; + + + a.teorias.add(t1.nombre, &t1) ; + a.teorias.add(t2.nombre, &t2) ; + a.teorias.add(t3.nombre, &t3) ; + a.teorias.add(t4.nombre, &t4) ; +#ifdef DEBUG + std::cout << "Agrega teoria: " << t1 << "\n"; + std::cout << "\tdatos_iniciales:\n" << t1.datos_iniciales << "\n"; + std::cout << "\tdatos_finales:\n" << t1.datos_finales << "\n"; + std::cout << "Agrega teoria: " << t2 << "\n"; + std::cout << "\tdatos_iniciales:\n" << t2.datos_iniciales << "\n"; + std::cout << "\tdatos_finales:\n" << t2.datos_finales << "\n"; + std::cout << "Agrega teoria: " << t3 << "\n"; + std::cout << "\tdatos_iniciales:\n" << t3.datos_iniciales << "\n"; + std::cout << "\tdatos_finales:\n" << t3.datos_finales << "\n"; + std::cout << "Agrega teoria: " << t4 << "\n"; + std::cout << "\tdatos_iniciales:\n" << t4.datos_iniciales << "\n"; + std::cout << "\tdatos_finales:\n" << t4.datos_finales << "\n"; +#endif // DEBUG + // Inicializo el SA delete a.p_entorno; a.p_entorno = e; - // Obtengo un plan CIndiceMagico datos_finales; - a.m_datos_finales.add ("robot.avanzo_en_x", 1) ; - a.plan(); - for (unsigned i=0; idatos, datos_finales, plan, p) ; + for (int i = 0; i < 3; ++i) + { -// for (unsigned i=0; iteorias.add(t->nombre.c_str(), *t); + sa->teorias.add(t->nombre, t); #ifdef DEBUG std::cout << "Agrega teoria " << t->nombre << ":\n"; std::cout << " .datos_iniciales:\n" << t->datos_iniciales << "\n"; diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp index 2eeb8dd..7469d10 100644 --- a/trunk/src/sistemaautonomo.cpp +++ b/trunk/src/sistemaautonomo.cpp @@ -1,5 +1,6 @@ #include "sistemaautonomo.h" +#include #ifdef DEBUG #include @@ -31,19 +32,20 @@ void CSistemaAutonomo::plan() double p = 1.0; m_plan.clear(); #ifdef DEBUG - std::cout << "entorno:\n" << p_entorno->datos << "\n"; - std::cout << "datos finales:\n" << m_datos_finales << "\n"; + std::cout << "SA: Planificando...\n"; + std::cout << "SA: \tentorno:\n" << p_entorno->datos << "\n"; + std::cout << "SA: \tdatos finales:\n" << m_datos_finales << "\n"; #endif // DEBUG planificar(p_entorno->datos, m_datos_finales, m_plan, p); #ifdef DEBUG - std::cout << "plan:\n" << m_plan << "\n"; + std::cout << "SA: \tplan:\n" << m_plan << "\n"; #endif // DEBUG curr_theory = m_plan.begin(); #ifdef DEBUG if (curr_theory == m_plan.end()) - std::cout << "No hay teorías\n"; + std::cout << "SA: No hay teorías\n"; else - std::cout << "curr teoria: " << &*curr_theory << "=" << curr_theory->nombre << "\n"; + std::cout << "SA: curr teoria: " << **curr_theory << "\n"; #endif // DEBUG } @@ -65,7 +67,7 @@ CTeoria* CSistemaAutonomo::get_next_theory() } else { - return &*(curr_theory++); + return *(curr_theory++); } } @@ -75,24 +77,35 @@ bool CSistemaAutonomo::validate_theory(CTeoria* t) { bool result ; + // Aumento k (cantidad de veces que se probó la teoría + ++t->k; + + // Verifico result = verificar_condicion(t->datos_finales) ; + // Si se ejecuto bien la teoria incremento el p + if (result) t->p++ ; // Si fallo la teoria if (!result) { + // Aplico heuristicas de observacion +#ifdef DEBUG + std::cout << "SA: No verifica, aplicando heuristicas...\n"; + std::cout << "SA: Aplicando heuristica de observacion\n"; +#endif // DEBUG + this->heuristca_observacion(*t) ; +#ifdef DEBUG + std::cout << "SA: Aplicando heuristica de generalizacion\n"; +#endif // DEBUG + this->heuristca_generalizacion(*t); +#ifdef DEBUG + std::cout << "SA: Aplicando heuristica de retraccion\n"; +#endif // DEBUG // Aplico heuristicas de correccion - this->heurisitca_retraccion(*t) ; - } - else - { - t->p++ ; + this->heuristca_retraccion(*t) ; } - // Aplico heuristicas de observacion - this->heurisitca_observacion(*t) ; - this->heurisitca_generalizacion(*t); - return result; } @@ -104,38 +117,44 @@ bool CSistemaAutonomo::verificar_condicion(CIndiceMagico& datos) bool result = true ; unsigned i ; + for (i = 0; i < datos.count() && result; i++) + result = (datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i))); - for (i=0; ip_entorno->datos.find(datos.keys(i)) ; - - - // return result ; } - +std::string make_nombre(const std::string& n, char mod, unsigned i) +{ + std::ostringstream oss; + oss << n << "-" << mod << i; + return oss.str(); +} //-------------------------------------------------------------------------------------------- //-- -void CSistemaAutonomo::heurisitca_observacion(CTeoria& t) +void CSistemaAutonomo::heuristca_observacion(CTeoria& t) { - CTeoria nt ; //Nueva Teoria - unsigned i ; - std::string nombre ; - + CTeoria* pnt = new CTeoria ; //Nueva Teoria + CTeoria& nt = *pnt; + // 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]) ; + nt.datos_finales = p_entorno->datos; + // Le cargo nombre y funcion (queda con k=1 y p=1) + nt.nombre = make_nombre(t.nombre, 'o', teorias.count()); + nt.funcion = t.funcion; // Agrego la teoria - nombre = teorias.count() ; - teorias.add (nombre.c_str(), nt) ; - + teorias.add (nt.nombre, pnt) ; +#ifdef DEBUG + std::cout << "SA: Se agrego una nueva teoria: " << nt << " basada en " << t << "\n"; + std::cout << "SA: \tdatos_iniciales:\n" << nt.datos_iniciales << "\n"; + std::cout << "SA: \tdatos_finales:\n" << nt.datos_finales << "\n"; +#endif // DEBUG + } //-------------------------------------------------------------------------------------------- @@ -143,9 +162,8 @@ void CSistemaAutonomo::heurisitca_observacion(CTeoria& t) // 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) +void CSistemaAutonomo::heuristca_generalizacion(CTeoria& t) { - CTeoria nt ; //Nueva Teoria unsigned i ; int count = 0; unsigned k = 0; @@ -156,40 +174,47 @@ void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t) cantidadTeorias = this->teorias.count(); - for (i=0; iteorias[i].datos_finales.count(); k++) + 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] != 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))) + if (this->teorias[i]->datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k))) { count++; } } } - if(count == 0) + if (count == 0) { // si se corresponden (las condiciones finales son iguales) => me fijo si hay alguna condicion inicial q cambia. - for (j=0; jteorias[i].datos_iniciales.count(); j++) + 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] != 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))) + 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; + if (count == 1) + { + //si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia. + CTeoria* nt = new CTeoria ; //Nueva Teoria + *nt = *this->teorias[i]; + nt->datos_iniciales[posicionCambio] = ANY; // Agrego la teoria - nombreTeoria = teorias.count() ; - teorias.add (nombreTeoria.c_str(), nt) ; + nt->nombre = make_nombre(t.nombre, 'g', teorias.count()); + teorias.add (nt->nombre, nt) ; +#ifdef DEBUG + std::cout << "SA: Se agrego una nueva teoria: " << *nt << " basada en " << *teorias[i] << "\n"; + std::cout << "SA: \tdatos_iniciales:\n" << nt->datos_iniciales << "\n"; + std::cout << "SA: \tdatos_finales:\n" << nt->datos_finales << "\n"; +#endif // DEBUG } } posicionCambio = -1; @@ -199,33 +224,46 @@ void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t) //-------------------------------------------------------------------------------------------- //-- -void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t) +void CSistemaAutonomo::heuristca_retraccion(CTeoria& t) { - CTeoria nt ; //Nueva Teoria unsigned i ; + unsigned modif = (unsigned)-1; // Recorro la condicion final de la teoria - for (i=0; ip_entorno->datos.find(t.datos_finales.keys(i)) - ) + t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))) + { // Le asigno ANY t.datos_finales[i] = ANY ; + modif = i; + } + } + if (modif != (unsigned)-1) + { + // Le cambio el nombre para indicar que fue modificada + t.nombre += "-r"; +#ifdef DEBUG + std::cout << "SA: Se modifica la teoria: " << t << ", el dato final '" + << t.datos_finales.keys(modif) << "' puede tomar ahora cualquier valor\n"; +#endif // DEBUG + } } //-------------------------------------------------------------------------------------------- //-- -void CSistemaAutonomo::planificar ( CIndiceMagico& datos_iniciales, - CIndiceMagico& datos_finales, - CIndiceMagico& plan, - double& p, - unsigned long numero_de_llamada) +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 ; + CIndiceMagico test_plan ; + CIndiceMagico new_plan ; double test_p ; double max_p = 0 ; @@ -234,18 +272,18 @@ void CSistemaAutonomo::planificar ( CIndiceMagico& datos_iniciales, if ( numero_de_llamada > 7 ) return ; - for (i=0; idatos_iniciales, datos_iniciales) ) { test_plan.clear() ; - test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ; + test_plan.add (teorias[i]->nombre, teorias[i]) ; - test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ; + 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) ; + 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) ) + if ( incluye_a(test_plan[test_plan.count()-1]->datos_finales, datos_finales) ) { max_p = test_p ; new_plan.clear() ; @@ -290,7 +328,7 @@ bool CSistemaAutonomo::ejecutar (CIndiceMagico& plan) if (!result) { // Aplico heuristicas de correccion - this->heurisitca_retraccion(t) ; + this->heuristca_retraccion(t) ; } else { @@ -298,8 +336,8 @@ bool CSistemaAutonomo::ejecutar (CIndiceMagico& plan) } // Aplico heuristicas de observacion - this->heurisitca_observacion(t) ; - this->heurisitca_generalizacion(t); + this->heuristca_observacion(t) ; + this->heuristca_generalizacion(t); } // diff --git a/trunk/src/sistemaautonomo.h b/trunk/src/sistemaautonomo.h index dd82f82..a7debcd 100644 --- a/trunk/src/sistemaautonomo.h +++ b/trunk/src/sistemaautonomo.h @@ -5,7 +5,7 @@ #include "indicemagico.h" #include #include -//#include +#include // DEFINICIONES: @@ -83,13 +83,15 @@ bool incluye_a (CIndiceMagico&, CIndiceMagico&) ; +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. @@ -123,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. @@ -138,9 +163,12 @@ public: } ; inline -std::ostream& operator<< (std::ostream& os, CTeoria& t) +std::ostream& operator<< (std::ostream& os, const CTeoria& t) { - return os << t.nombre << " > " << t.funcion; + 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"; } @@ -177,7 +205,7 @@ public: CIndiceMagico m_datos_finales; // Las teorias que tiene el SA. - CIndiceMagico teorias ; + CIndiceMagico teorias ; public: // Constructor @@ -203,31 +231,31 @@ public: bool verificar_condicion(CIndiceMagico& datos) ; // plan actual - CIndiceMagico m_plan; + CIndiceMagico m_plan; // teoria actual - CIndiceMagico::iterator curr_theory; + CIndiceMagico::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 heurisitca_generalizacion(CTeoria&); + void heuristca_generalizacion(CTeoria&); public: void planificar (CIndiceMagico& datos_iniciales, CIndiceMagico& datos_finales, - CIndiceMagico& plan, + CIndiceMagico& plan, double& p, unsigned long numero_de_llamada=0) ; -- 2.43.0