X-Git-Url: https://git.llucax.com/z.facultad/75.68/celdas.git/blobdiff_plain/a4c9e136c32a1686046eaf6c6e1902cac4b7bb73..537dc1e46f6cdfa39e6e3771048242d18aeb464f:/trunk/src/sistemaautonomo.cpp diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp index 2eeb8dd..23a33e3 100644 --- a/trunk/src/sistemaautonomo.cpp +++ b/trunk/src/sistemaautonomo.cpp @@ -1,5 +1,6 @@ #include "sistemaautonomo.h" +#include #ifdef DEBUG #include @@ -31,20 +32,23 @@ 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: \tteorias:\n" << teorias << "\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 + if (teorias.count() > TEORIAS_MAX) purgar_teorias(); } //-------------------------------------------------------------------------------------------- @@ -65,7 +69,7 @@ CTeoria* CSistemaAutonomo::get_next_theory() } else { - return &*(curr_theory++); + return *(curr_theory++); } } @@ -75,23 +79,34 @@ 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) ; + this->heuristca_retraccion(*t) ; } - else - { - t->p++ ; - } - - // Aplico heuristicas de observacion - this->heurisitca_observacion(*t) ; - this->heurisitca_generalizacion(*t); return result; } @@ -104,38 +119,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 +164,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 +176,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,53 +226,66 @@ 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 ; if ( incluye_a(datos_iniciales, datos_finales) ) return ; - if ( numero_de_llamada > 7 ) return ; + if ( numero_de_llamada > PASOS_MAXIMOS_DE_PLAN ) 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() ; @@ -257,52 +297,24 @@ void CSistemaAutonomo::planificar ( CIndiceMagico& datos_iniciales, plan.add (new_plan) ; } - -/* -//-------------------------------------------------------------------------------------------- -//-- -bool CSistemaAutonomo::ejecutar (CIndiceMagico& plan) +void CSistemaAutonomo::purgar_teorias() { - 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) + double p = (double)teorias[i]->p / (double)teorias[i]->k; + if (p < whorst_prob) { - // Aplico heuristicas de correccion - this->heurisitca_retraccion(t) ; + whorst_prob = p; + pos = i; } - else - { - t.p++ ; - } - - // Aplico heuristicas de observacion - this->heurisitca_observacion(t) ; - this->heurisitca_generalizacion(t); } - - // - return result ; + teorias.remove(pos); +#ifdef DEBUG + std::cout << "SA: Se purgo la teoria " << *teorias[pos] << "\n"; +#endif // DEBUG + if (size - 1 > TEORIAS_MAX) purgar_teorias(); } -*/ +