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 void CSistemaAutonomo::plan()
  26 {
  27         double p = 1.0;
  28         m_plan.clear();
  29         planificar(p_entorno->datos, m_datos_finales, m_plan, p);
  30         curr_theory = m_plan.begin();
  31 }
  32
  33 //--------------------------------------------------------------------------------------------
  34 //--
  35 #include <iostream> // XXX FIXME
  36 bool CSistemaAutonomo::has_next_theory()
  37 {
  38         return curr_theory != m_plan.end();
  39 }
  40
  41 //--------------------------------------------------------------------------------------------
  42 //--
  43 CTeoria* CSistemaAutonomo::get_next_theory()
  44 {
  45         if (curr_theory == m_plan.end())
  46         {
  47                 m_datos_finales.clear();
  48                 return 0;
  49         }
  50         else
  51         {
  52                 return &*(curr_theory++);
  53         }
  54 }
  55
  56 //--------------------------------------------------------------------------------------------
  57 //--
  58 bool CSistemaAutonomo::validate_theory(CTeoria* t)
  59 {
  60         bool result ;
  61
  62         result = verificar_condicion(t->datos_finales) ;
  63
  64
  65         // Si fallo la teoria
  66         if (!result)
  67         {
  68                 // Aplico heuristicas de correccion
  69                 this->heurisitca_retraccion(*t) ;
  70         }
  71         else
  72         {
  73                 t->p++ ;
  74         }
  75
  76         // Aplico heuristicas de observacion
  77         this->heurisitca_observacion(*t) ;
  78         this->heurisitca_generalizacion(*t);
  79
  80         return result;
  81 }
  82
  83
  84 //--------------------------------------------------------------------------------------------
  85 //--
  86 bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>&       datos)
  87 {
  88         bool result = true ;
  89         unsigned i ;
  90
  91
  92         for (i=0; i<datos.count() && result; i++)
  93                 result = datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i))  ;
  94
  95
  96         //
  97         return result ;
  98 }
  99
 100
 101
 102 //--------------------------------------------------------------------------------------------
 103 //--
 104 void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
 105 {
 106         CTeoria nt ; //Nueva Teoria
 107         unsigned i ;
 108         std::string nombre ;
 109
 110         // Le agrego los datos iniciales tal cual estaban antes
 111         for (i=0; i<t.datos_iniciales.count(); i++)
 112                 nt.datos_iniciales.add(t.datos_iniciales.keys(i), t.datos_iniciales[i]) ;
 113
 114         // Le agrego todas las condiciones del entorno como condicion final
 115         for (i=0; i<this->p_entorno->datos.count(); i++)
 116                 nt.datos_finales.add(this->p_entorno->datos.keys(i), this->p_entorno->datos[i]) ;
 117
 118
 119         // Agrego la teoria
 120         nombre = teorias.count() ;
 121         teorias.add (nombre.c_str(), nt) ;
 122
 123 }
 124
 125 //--------------------------------------------------------------------------------------------
 126 //--
 127 // Si las condiciones finales del entorno son iguales a las condiciones finales de alguna teoria y
 128 // solo una condicion inicial es distinta => agrego una nueva teoría igual (a la q cumple los requisitos
 129 // anteriormente detallados) pero tomando ANY en el valor de entrada en el cual difieren.
 130 void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t)
 131 {
 132         CTeoria nt ; //Nueva Teoria
 133         unsigned i ;
 134         int count = 0;
 135         unsigned k = 0;
 136         unsigned j = 0;
 137         int posicionCambio = -1;
 138         unsigned cantidadTeorias = 0;
 139         std::string nombreTeoria;
 140
 141         cantidadTeorias = this->teorias.count();
 142
 143         for (i=0; i<cantidadTeorias; i++)
 144         {
 145                 for (k=0; k<this->teorias[i].datos_finales.count(); k++)
 146                 {
 147                         //me fijo si las condiciones finales de la teoria se corresponden con la del entorno.
 148                         if((this->teorias[i].datos_finales[k] != ANY) && (this->p_entorno->datos.find(t.datos_finales.keys(k)) != ANY))
 149                         {
 150                                 if(this->teorias[i].datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k)))
 151                                 {
 152                                         count++;
 153                                 }
 154                         }
 155                 }
 156                 if(count == 0)
 157                 {       // si se corresponden (las condiciones finales son iguales) => me fijo si hay alguna condicion inicial q cambia.
 158                         for (j=0; j<this->teorias[i].datos_iniciales.count(); j++)
 159                         {
 160                                 if((this->teorias[i].datos_iniciales[j] != ANY) && (this->p_entorno->datos.find(t.datos_iniciales.keys(j)) != ANY))
 161                                 {
 162                                         if(this->teorias[i].datos_iniciales[j] != this->p_entorno->datos.find(t.datos_iniciales.keys(j)))
 163                                         {
 164                                                 posicionCambio = j;
 165                                                 count++;
 166                                         }
 167                                 }
 168                         }
 169                         if(count == 1)
 170                         {//si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia.
 171                                 nt = this->teorias[i];
 172                                 nt.datos_iniciales[posicionCambio] = ANY;
 173
 174                                 // Agrego la teoria
 175                                 nombreTeoria = teorias.count() ;
 176                                 teorias.add (nombreTeoria.c_str(), nt) ;
 177                         }
 178                 }
 179                 posicionCambio = -1;
 180                 count = 0;
 181         }
 182 }
 183
 184 //--------------------------------------------------------------------------------------------
 185 //--
 186 void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
 187 {
 188         CTeoria nt ; //Nueva Teoria
 189         unsigned i ;
 190
 191         // Recorro la condicion final de la teoria
 192         for (i=0; i<t.datos_finales.count(); i++)
 193                 // Si el dato no coincidio con el del entorno, y no era ANY
 194                 if (t.datos_finales[i] != ANY &&
 195                         t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
 196                    )
 197                         // Le asigno ANY
 198                         t.datos_finales[i] = ANY ;
 199 }
 200
 201
 202 //--------------------------------------------------------------------------------------------
 203 //--
 204 void CSistemaAutonomo::planificar (     CIndiceMagico<t_dato>&  datos_iniciales,
 205                                                                         CIndiceMagico<t_dato>&  datos_finales,
 206                                                                         CIndiceMagico<CTeoria>& plan,
 207                                                                         double&                                 p,
 208                                                                         unsigned long                   numero_de_llamada)
 209 {
 210         unsigned i;
 211         CIndiceMagico<CTeoria> test_plan ;
 212         CIndiceMagico<CTeoria> new_plan ;
 213         double test_p ;
 214         double max_p = 0 ;
 215
 216
 217         if ( incluye_a(datos_iniciales, datos_finales) ) return ;
 218
 219         if ( numero_de_llamada > 7 ) return ;
 220
 221         for (i=0; i<teorias.count(); i++)
 222                 if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
 223                 {
 224                         test_plan.clear() ;
 225                         test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
 226
 227                         test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ;
 228
 229                         planificar(teorias[i].datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ;
 230
 231                         if ( test_p>max_p )
 232                         if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
 233                         {
 234                                 max_p = test_p ;
 235                                 new_plan.clear() ;
 236                                 new_plan.add (test_plan) ;
 237                         }
 238                 }
 239
 240         if (max_p>0)
 241                 plan.add (new_plan) ;
 242 }
 243
 244
 245 /*
 246 //--------------------------------------------------------------------------------------------
 247 //--
 248 bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
 249 {
 250         bool result = true ;
 251         unsigned i ;
 252         t_fnc(pFnc) ;
 253         CTeoria t ;
 254
 255
 256         for (i=0; i<plan.count() && result; i++)
 257         {
 258                 t = plan[i] ;
 259                 pFnc = t.funcion;
 260
 261                 // Ejecuto la funcion
 262                 (*pFnc)(*(this->p_entorno)) ;
 263
 264                 // Incremento el K
 265                 t.k++ ;
 266
 267                 // Actualizo los datos del entorno
 268                 this->p_entorno->actualizar() ;
 269
 270                 // Veo si se verifica la condicion final
 271                 result = this->verificar_condicion(t.datos_finales) ;
 272
 273                 // Si fallo la teoria
 274                 if (!result)
 275                 {
 276                         // Aplico heuristicas de correccion
 277                         this->heurisitca_retraccion(t) ;
 278                 }
 279                 else
 280                 {
 281                         t.p++ ;
 282                 }
 283
 284                 // Aplico heuristicas de observacion
 285                 this->heurisitca_observacion(t) ;
 286                 this->heurisitca_generalizacion(t);
 287         }
 288
 289         //
 290         return result ;
 291 }
 292 */