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