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 // Si las condiciones finales del entorno son iguales a las condiciones finales de alguna teoria y
  69 // solo una condicion inicial es distinta => agrego una nueva teoría igual (a la q cumple los requisitos
  70 // anteriormente detallados) pero tomando ANY en el valor de entrada en el cual difieren.
  71 void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t)
  72 {
  73         CTeoria nt ; //Nueva Teoria
  74         unsigned i ;
  75         int count = 0;
  76         int k = 0;
  77         int j = 0;
  78         int posicionCambio = -1;
  79         bool seguir = true;
  80         unsigned cantidadTeorias = 0;
  81         std::string nombreTeoria;
  82
  83         cantidadTeorias = this->teorias.count();
  84
  85         for (i=0; i<cantidadTeorias; i++)
  86         {
  87                 for (k=0; k<this->teorias[i].datos_finales.count(); k++)
  88                 {
  89                         //me fijo si las condiciones finales de la teoria se corresponden con la del entorno.
  90                         if((this->teorias[i].datos_finales[k] != ANY) && (this->p_entorno->datos.find(t.datos_finales.keys(k)) != ANY))
  91                         {
  92                                 if(this->teorias[i].datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k)))
  93                                 {
  94                                         count++;
  95                                 }
  96                         }
  97                 }
  98                 if(count == 0)
  99                 {       // si se corresponden (las condiciones finales son iguales) => me fijo si hay alguna condicion inicial q cambia.
 100                         for (j=0; j<this->teorias[i].datos_iniciales.count(); j++)
 101                         {
 102                                 if((this->teorias[i].datos_iniciales[j] != ANY) && (this->p_entorno->datos.find(t.datos_iniciales.keys(j)) != ANY))
 103                                 {
 104                                         if(this->teorias[i].datos_iniciales[j] != this->p_entorno->datos.find(t.datos_iniciales.keys(j)))
 105                                         {
 106                                                 posicionCambio = j;
 107                                                 count++;
 108                                         }
 109                                 }
 110                         }
 111                         if(count == 1)
 112                         {//si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia.
 113                                 nt = this->teorias[i];
 114                                 nt.datos_iniciales[posicionCambio] = ANY;
 115
 116                                 // Agrego la teoria
 117                                 nombreTeoria = teorias.count() ;
 118                                 teorias.add (nombreTeoria.c_str(), nt) ;
 119                         }
 120                 }
 121                 posicionCambio = -1;
 122                 count = 0;
 123         }
 124 }
 125
 126 //--------------------------------------------------------------------------------------------
 127 //--
 128 void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
 129 {
 130         CTeoria nt ; //Nueva Teoria
 131         unsigned i ;
 132
 133         // Recorro la condicion final de la teoria
 134         for (i=0; i<t.datos_finales.count(); i++)
 135                 // Si el dato no coincidio con el del entorno, y no era ANY
 136                 if (t.datos_finales[i] != ANY &&
 137                         t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
 138                    )
 139                         // Le asigno ANY
 140                         t.datos_finales[i] = ANY ;
 141 }
 142
 143
 144 //--------------------------------------------------------------------------------------------
 145 //--
 146 void CSistemaAutonomo::planificar (     CIndiceMagico<t_dato>&  datos_iniciales,
 147                                                                         CIndiceMagico<t_dato>&  datos_finales,
 148                                                                         CIndiceMagico<CTeoria>& plan,
 149                                                                         double&                                 p,
 150                                                                         unsigned long                   numero_de_llamada)
 151 {
 152         unsigned i;
 153         CIndiceMagico<CTeoria> test_plan ;
 154         CIndiceMagico<CTeoria> new_plan ;
 155         double test_p ;
 156         double max_p = 0 ;
 157
 158
 159         if ( incluye_a(datos_iniciales, datos_finales) ) return ;
 160
 161         if ( numero_de_llamada > 7 ) return ;
 162
 163         for (i=0; i<teorias.count(); i++)
 164                 if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
 165                 {
 166                         test_plan.clear() ;
 167                         test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
 168
 169                         test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ;
 170
 171                         planificar(teorias[i].datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ;
 172
 173                         if ( test_p>max_p )
 174                         if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
 175                         {
 176                                 max_p = test_p ;
 177                                 new_plan.clear() ;
 178                                 new_plan.add (test_plan) ;
 179                         }
 180                 }
 181
 182         if (max_p>0)
 183                 plan.add (new_plan) ;
 184 }
 185
 186
 187
 188 //--------------------------------------------------------------------------------------------
 189 //--
 190 bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
 191 {
 192         bool result = true ;
 193         unsigned i ;
 194         t_fnc(pFnc) ;
 195         CTeoria t ;
 196
 197
 198         for (i=0; i<plan.count() && result; i++)
 199         {
 200                 t = plan[i] ;
 201                 pFnc = t.funcion;
 202
 203                 // Ejecuto la funcion
 204                 (*pFnc)(*(this->p_entorno)) ;
 205
 206                 // Incremento el K
 207                 t.k++ ;
 208
 209                 // Actualizo los datos del entorno
 210                 this->p_entorno->actualizar() ;
 211
 212                 // Veo si se verifica la condicion final
 213                 result = this->verificar_condicion(t.datos_finales) ;
 214
 215                 // Si fallo la teoria
 216                 if (!result)
 217                 {
 218                         // Aplico heuristicas de correccion
 219                         this->heurisitca_retraccion(t) ;
 220                 }
 221                 else
 222                 {
 223                         t.p++ ;
 224                 }
 225
 226                 // Aplico heuristicas de observacion
 227                 this->heurisitca_observacion(t) ;
 228                 this->heurisitca_generalizacion(t);
 229         }
 230
 231         //
 232         return result ;
 233 }