Arreglo bug horrible. El get-sensor-value era una especie de random (lo que no

[z.facultad/75.68/celdas.git] / trunk / src / sistemaautonomo.cpp

diff --git a/trunk/src/sistemaautonomo.cpp b/trunk/src/sistemaautonomo.cpp
index f4cbbabe9b918b575997e7f4c2ba5fe2997c8b54..5f1cf2c7b12b221b89cecaf6b5b185bfd4a1c0f6 100644 (file)
--- a/trunk/src/sistemaautonomo.cpp
+++ b/trunk/src/sistemaautonomo.cpp
@@ -4,19 +4,170 @@
 
 //--------------------------------------------------------------------------------------------
 //-- 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)) ;
+
+       // 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 ;
+}
 
-bool cumple_condiciones (CIndiceMagico<t_dato>& muestra, CIndiceMagico<t_dato>& patron) 
-{
 
+
+//--------------------------------------------------------------------------------------------
+//--
+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) ;
+       
 }
 
+
+//--------------------------------------------------------------------------------------------
+//--
+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) ;
+       }
+
+       //
+       return result ;
+}