trunk/src/sistemaautonomo.h

   1
   2 #ifndef __SISTEMAAUTONOMO__
   3 #define __SISTEMAAUTONOMO__
   4
   5 #include "indicemagico.h"
   6 #include <math.h>
   7 #include <string>
   8 //#include <map>
   9
  10
  11 // DEFINICIONES:
  12 // ------------
  13 //
  14 //      ENTORNO:                        Variables que definen el entorno.
  15 //  CONDICION                   va=a AND vb=b AND vc=c.
  16 //      TEORIA:                         Se cumple condicion_inicial y ejecuto funcion F, entonces se cumplira condicion_final.
  17 //      SISTEMA AUTONOMO:       Tiene un ENTORNO y una cantidad de TEORIAS.
  18 //      CICLO:                          Son los pasos de:
  19 //                                                      * Tomar los valores el entorno.
  20 //                                                      * Decidir una condicion que deberia cumplir el entorno.
  21 //                                                      * Planificar (PLAN) una serie de acciones (PASOS) para alcanzar la condicion deseada.
  22 //                                                      * Ejecutar el plan, verificando en cada paso que se vayan cumpliendo las teorias intermedias.
  23 //      PLAN:
  24 //      PASO:
  25
  26 class CEntorno ;
  27
  28
  29 typedef double t_dato ;
  30 #define ANY -3000000
  31
  32
  33 #define t_fnc(name)             double (*name)(CEntorno&)
  34
  35
  36 #define INFINITO        9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long
  37
  38
  39 // ------------------------------------------
  40 // Parametros de configuracion de SA
  41
  42
  43 // [Ejecutador]
  44
  45 // Precision en la comparacion de atributos.
  46 // Poner en 0 si se quiere hacer la comparacion exacta.
  47 #define PRECISION                                                               0.50000
  48
  49 // Cuando se ejecuta un plan, se espera que al termina el ultimo paso se hallan alcanzado las condiciones finales.
  50 // Es posible que las condiciones finales se alcancen en algun paso previo.
  51 // Esto permite generar nuevas teorias, pero quita performance al proceso de ejecucion.
  52 //#define VERIFICAL_RESULTADOS_EN_CADA_PASO             true
  53
  54
  55 // [Planificador]
  56
  57 // Cantidad maxima de pasos que puede tener un plan.
  58 // Cuanto mas grande sea este numero, mas ciclos puede tardar el proceso de planificacion.
  59 // Este valor es un compromiso entre performance y eficiencia.
  60 #define PASOS_MAXIMOS_DE_PLAN           20
  61
  62 // El metodo de planificacion puede encontrar varios planes, y de ellos elige el mejor.
  63 // Si se hace seleccionar TODOS los posibles planes, puede tardar demasiado.
  64 // Una opcion es determinar una cantidad maxima de posibles planes que se pueden testear.
  65 // Este valor es un compromiso entre performance y eficiencia.
  66 // Poner INFINITO si se desea deshabilitar esta opcion.
  67 #define PLANES_MAXIMOS_TESTEADOS        10
  68
  69 // Es la minima relacion P/K que puede tener una teoria para considerarse como aceptable.
  70 #define TOLERANCIA                                      0.75
  71
  72
  73 // [Heuristicas]
  74
  75 // Cantidad de ciclos que se recuerda una teoria.
  76 // Poner INFINITO si se desea deshabilitar esta opcion.
  77 #define CICLOS_DE_MEMORIA                       10
  78
  79
  80
  81
  82 bool incluye_a (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
  83
  84
  85
  86
  87 // CTeoria
  88 class CTeoria
  89 {
  90 public:
  91
  92         std::string                             nombre ;
  93
  94         // Condiciones iniciales de la teoria.
  95         // Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.
  96         // Las condiciones se concatenan con un operador &&
  97         CIndiceMagico<t_dato>   datos_iniciales ;
  98
  99         // La funcion que se debe ejecutar para hacer valer la teoria.
 100         double (*funcion)(CEntorno& e) ;
 101
 102         // Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial
 103         CIndiceMagico<t_dato>   datos_finales ;
 104
 105 public:
 106         CTeoria()
 107         {
 108                 nombre = "" ;
 109                 funcion = NULL ;
 110                 k = 1 ;
 111                 p = 1 ;
 112         }
 113
 114         CTeoria(const char* ini_nombre,
 115                         double (*ini_funcion)(CEntorno& e),
 116                         unsigned long ini_k,
 117                         unsigned long ini_p)
 118         {
 119                 nombre = ini_nombre ;
 120                 funcion = ini_funcion ;
 121                 k = ini_k ;
 122                 p = ini_p ;
 123         }
 124
 125
 126 public:
 127         // Cantidad de veces que se probo la teoria.
 128         unsigned long                   k ;
 129
 130         // Cantidad de veces que se probo la teoria y resulto correcta.
 131         unsigned long                   p ;
 132
 133         // Cantidad de ciclos ocurridos desde que se creo la teoria.
 134         // Este parametro se usa para quitarle memoria al SA.
 135         unsigned long                   ciclos ;
 136
 137 } ;
 138
 139
 140
 141 // CEntorno
 142 class CEntorno
 143 {
 144 public:
 145         CIndiceMagico<t_dato>   datos ;
 146
 147 public:
 148 //      CEntorno() { this->inicializar() ; }
 149
 150 public:
 151         // Inicializar los datos
 152         virtual void inicializar() {} ;
 153
 154         // Actualizar los datos
 155         virtual void actualizar() {} ;
 156
 157         // Destructor
 158         virtual ~CEntorno() {}
 159 } ;
 160
 161
 162
 163 // CSistemaAutonomo
 164 class CSistemaAutonomo
 165 {
 166 public:
 167         // El entono en el que se mueve el SA.
 168         CEntorno*                                       p_entorno ;
 169
 170         // Las teorias que tiene el SA.
 171         CIndiceMagico<CTeoria>          teorias ;
 172
 173 public:
 174         // Retorna true si los valores de la condicion coinciden con los valores del entorno.
 175         bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;
 176
 177
 178 protected:
 179
 180         // Heuristica de observacion.
 181         //      Segun la teoria que se ejecuto, se crea una nueva teoria con TODOS/ALGUNOS valores actuales del entorno como condicion_final.
 182         void heurisitca_observacion(CTeoria&) ;
 183
 184         // Heuristica de correccion por retraccion.
 185         //      Si una teoria no se verifico como correcta, se crea una nueva quitandole las condiciones_finales que no se verifican.
 186         void heurisitca_retraccion(CTeoria&) ;
 187
 188
 189 public:
 190
 191
 192         void planificar (       CIndiceMagico<t_dato>&  datos_iniciales,
 193                                                 CIndiceMagico<t_dato>&  datos_finales,
 194                                                 CIndiceMagico<CTeoria>& plan,
 195                                                 double&                                 p,
 196                                                 unsigned long                   numero_de_llamada=0) ;
 197
 198
 199         // Ejecuta una serie de pasos.
 200         // Retorna true si se alcanza la condicion final.
 201         bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
 202
 203
 204 } ;
 205
 206
 207
 208 #endif
 209