//--------------------------------------------------------------------------------------------
//-- Funciones Auxiliares
+bool incluye_a (CIndiceMagico<t_dato>& a, CIndiceMagico<t_dato>& b)
+{
+ bool result = true ;
+ unsigned i ;
+ // Todas las variables de la condicion b deben estar en la condicion a
+ for (i=0; i<b.count() && result; i++)
+ result=a.exist(b.keys(i)) ;
-bool cumple_condiciones (CIndiceMagico<t_dato>& muestra, CIndiceMagico<t_dato>& patron)
+ // Todas las variables de la condicion a deben tener el mismo valor que en la condicion b
+ for (i=0; i<b.count() && result; i++)
+ result = b[i] == a.find(b.keys(i)) || b[i] == ANY || a.find(b.keys(i)) == ANY ;
+ //
+ return result ;
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::plan()
{
+ double p = 1.0;
+ m_plan.clear();
+ planificar(p_entorno->datos, m_datos_finales, m_plan, p);
+ curr_theory = m_plan.begin();
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+#include <iostream> // XXX FIXME
+bool CSistemaAutonomo::has_next_theory()
+{
+ return curr_theory != m_plan.end();
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+CTeoria* CSistemaAutonomo::get_next_theory()
+{
+ if (curr_theory == m_plan.end())
+ {
+ m_datos_finales.clear();
+ return 0;
+ }
+ else
+ {
+ return &*(curr_theory++);
+ }
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::validate_theory(CTeoria* t)
+{
+ bool result ;
+
+ result = 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) ;
+ this->heurisitca_generalizacion(*t);
+
+ return result;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>& datos)
+{
bool result = true ;
unsigned i ;
- for (i=0; i<muestra.count() && result; i++)
- result = (muestra[i] == patron.find(muestra.keys(i))) ;
+
+ for (i=0; i<datos.count() && result; i++)
+ result = datos[i] == ANY || datos[i] == this->p_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; i<t.datos_iniciales.count(); i++)
+ nt.datos_iniciales.add(t.datos_iniciales.keys(i), t.datos_iniciales[i]) ;
+
+ // Le agrego todas las condiciones del entorno como condicion final
+ for (i=0; i<this->p_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) ;
+
}
+//--------------------------------------------------------------------------------------------
+//--
+// 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)
+{
+ CTeoria nt ; //Nueva Teoria
+ unsigned i ;
+ int count = 0;
+ unsigned k = 0;
+ unsigned j = 0;
+ int posicionCambio = -1;
+ unsigned cantidadTeorias = 0;
+ std::string nombreTeoria;
+
+ cantidadTeorias = this->teorias.count();
+
+ for (i=0; i<cantidadTeorias; i++)
+ {
+ 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] != this->p_entorno->datos.find(t.datos_finales.keys(k)))
+ {
+ count++;
+ }
+ }
+ }
+ if(count == 0)
+ { // si se corresponden (las condiciones finales son iguales) => me fijo si hay alguna condicion inicial q cambia.
+ 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] != 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;
+
+ // Agrego la teoria
+ nombreTeoria = teorias.count() ;
+ teorias.add (nombreTeoria.c_str(), nt) ;
+ }
+ }
+ posicionCambio = -1;
+ count = 0;
+ }
+}
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
+{
+ CTeoria nt ; //Nueva Teoria
+ unsigned i ;
+
+ // Recorro la condicion final de la teoria
+ for (i=0; i<t.datos_finales.count(); i++)
+ // Si el dato no coincidio con el del entorno, y no era ANY
+ if (t.datos_finales[i] != ANY &&
+ t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
+ )
+ // Le asigno ANY
+ t.datos_finales[i] = ANY ;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::planificar ( CIndiceMagico<t_dato>& datos_iniciales,
+ CIndiceMagico<t_dato>& datos_finales,
+ CIndiceMagico<CTeoria>& plan,
+ double& p,
+ unsigned long numero_de_llamada)
+{
+ unsigned i;
+ CIndiceMagico<CTeoria> test_plan ;
+ CIndiceMagico<CTeoria> 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; i<teorias.count(); i++)
+ if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
+ {
+ test_plan.clear() ;
+ test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
+
+ 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) ;
+
+ if ( test_p>max_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<CTeoria>& plan)
+{
+ bool result = true ;
+ unsigned i ;
+ t_fnc(pFnc) ;
+ CTeoria t ;
+
+
+ for (i=0; i<plan.count() && result; i++)
+ {
+ t = plan[i] ;
+ pFnc = t.funcion;
+
+ // Ejecuto la funcion
+ (*pFnc)(*(this->p_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) ;
+ this->heurisitca_generalizacion(t);
+ }
+
+ //
+ return result ;
+}
+*/
projects / z.facultad / 75.68 / celdas.git / blobdiff