trunk/src/sistemaautonomo.cpp

   1
   2 #include "sistemaautonomo.h"
   3
   4
   5 //--------------------------------------------------------------------------------------------
   6 //-- Funciones Auxiliares
   7 bool incluye_a (CIndiceMagico<t_dato>& a, CIndiceMagico<t_dato>& b)
   8 {
   9         bool result = true ;
  10         unsigned i ;
  11
  12         // Todas las variables de la condicion b deben estar en la condicion a
  13         for (i=0; i<b.count() && result; i++)
  14                 result=a.exist(b.keys(i)) ;
  15
  16         // Todas las variables de la condicion a deben tener el mismo valor que en la condicion b
  17         for (i=0; i<b.count() && result; i++)
  18                 result = b[i] == a.find(b.keys(i)) || b[i] == ANY || a.find(b.keys(i)) == ANY  ;
  19         //
  20         return result ;
  21 }
  22
  23
  24
  25 //--------------------------------------------------------------------------------------------
  26 //--
  27 bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>&       datos)
  28 {
  29         bool result = true ;
  30         unsigned i ;
  31
  32
  33         for (i=0; i<datos.count() && result; i++)
  34                 result = datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i))  ;
  35
  36
  37         //
  38         return result ;
  39 }
  40
  41
  42
  43 //--------------------------------------------------------------------------------------------
  44 //--
  45 void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
  46 {
  47         CTeoria nt ; //Nueva Teoria
  48         unsigned i ;
  49         std::string nombre ;
  50
  51         // Le agrego los datos iniciales tal cual estaban antes
  52         for (i=0; i<t.datos_iniciales.count(); i++)
  53                 nt.datos_iniciales.add(t.datos_iniciales.keys(i), t.datos_iniciales[i]) ;
  54
  55         // Le agrego todas las condiciones del entorno como condicion final
  56         for (i=0; i<this->p_entorno->datos.count(); i++)
  57                 nt.datos_finales.add(this->p_entorno->datos.keys(i), this->p_entorno->datos[i]) ;
  58
  59
  60         // Agrego la teoria
  61         nombre = teorias.count() ;
  62         teorias.add (nombre.c_str(), nt) ;
  63
  64 }
  65
  66
  67 //--------------------------------------------------------------------------------------------
  68 //--
  69 void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
  70 {
  71         CTeoria nt ; //Nueva Teoria
  72         unsigned i ;
  73
  74         // Recorro la condicion final de la teoria
  75         for (i=0; i<t.datos_finales.count(); i++)
  76                 // Si el dato no coincidio con el del entorno, y no era ANY
  77                 if (t.datos_finales[i] != ANY &&
  78                         t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
  79                    )
  80                         // Le asigno ANY
  81                         t.datos_finales[i] = ANY ;
  82 }
  83
  84
  85 //--------------------------------------------------------------------------------------------
  86 //--
  87 void CSistemaAutonomo::planificar (     CIndiceMagico<t_dato>&  datos_iniciales,
  88                                                                         CIndiceMagico<t_dato>&  datos_finales,
  89                                                                         CIndiceMagico<CTeoria>& plan,
  90                                                                         double&                                 p,
  91                                                                         unsigned long                   numero_de_llamada)
  92 {
  93         unsigned i;
  94         CIndiceMagico<CTeoria> test_plan ;
  95         CIndiceMagico<CTeoria> new_plan ;
  96         double test_p ;
  97         double max_p = 0 ;
  98
  99
 100         if ( incluye_a(datos_iniciales, datos_finales) ) return ;
 101
 102         if ( numero_de_llamada > 7 ) return ;
 103
 104         for (i=0; i<teorias.count(); i++)
 105                 if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
 106                 {
 107                         test_plan.clear() ;
 108                         test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
 109
 110                         test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ;
 111
 112                         planificar(teorias[i].datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ;
 113
 114                         if ( test_p>max_p )
 115                         if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
 116                         {
 117                                 max_p = test_p ;
 118                                 new_plan.clear() ;
 119                                 new_plan.add (test_plan) ;
 120                         }
 121                 }
 122
 123         if (max_p>0)
 124                 plan.add (new_plan) ;
 125 }
 126
 127
 128
 129 //--------------------------------------------------------------------------------------------
 130 //--
 131 bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
 132 {
 133         bool result = true ;
 134         unsigned i ;
 135         t_fnc(pFnc) ;
 136         CTeoria t ;
 137
 138
 139         for (i=0; i<plan.count() && result; i++)
 140         {
 141                 t = plan[i] ;
 142                 pFnc = t.funcion;
 143
 144                 // Ejecuto la funcion
 145                 (*pFnc)(*(this->p_entorno)) ;
 146
 147                 // Incremento el K
 148                 t.k++ ;
 149
 150                 // Actualizo los datos del entorno
 151                 this->p_entorno->actualizar() ;
 152
 153                 // Veo si se verifica la condicion final
 154                 result = this->verificar_condicion(t.datos_finales) ;
 155
 156                 // Si fallo la teoria
 157                 if (!result)
 158                 {
 159                         // Aplico heuristicas de correccion
 160                         this->heurisitca_retraccion(t) ;
 161                 }
 162                 else
 163                 {
 164                         t.p++ ;
 165                 }
 166
 167                 // Aplico heuristicas de observacion
 168                 this->heurisitca_observacion(t) ;
 169         }
 170
 171         //
 172         return result ;
 173 }