El sensor ahora devuelve valor binario (0 si no tiene nada adelante, 1 si sí tiene).

[z.facultad/75.68/celdas.git] / trunk / src / sistemaautonomo.h

#ifndef __SISTEMAAUTONOMO__
#define __SISTEMAAUTONOMO__

#include "indicemagico.h"
#include <math.h>
#include <string>
#include <iostream>


// DEFINICIONES:
// ------------
//
//      ENTORNO:                        Variables que definen el entorno.
//  CONDICION                   va=a AND vb=b AND vc=c.
//      TEORIA:                         Se cumple condicion_inicial y ejecuto funcion F, entonces se cumplira condicion_final.
//      SISTEMA AUTONOMO:       Tiene un ENTORNO y una cantidad de TEORIAS.
//      CICLO:                          Son los pasos de:
//                                                      * Tomar los valores el entorno.
//                                                      * Decidir una condicion que deberia cumplir el entorno.
//                                                      * Planificar (PLAN) una serie de acciones (PASOS) para alcanzar la condicion deseada.
//                                                      * Ejecutar el plan, verificando en cada paso que se vayan cumpliendo las teorias intermedias.
//      PLAN:
//      PASO:

class CEntorno ;


typedef double t_dato ;
#define ANY -3000000


//#define t_fnc(name)           double (*name)(CEntorno&)


#define INFINITO        9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long


// ------------------------------------------
// Parametros de configuracion de SA


// [Ejecutador]

// Precision en la comparacion de atributos.
// Poner en 0 si se quiere hacer la comparacion exacta.
#define PRECISION                                                               0.150000

// Cuando se ejecuta un plan, se espera que al termina el ultimo paso se hallan alcanzado las condiciones finales.
// Es posible que las condiciones finales se alcancen en algun paso previo.
// Esto permite generar nuevas teorias, pero quita performance al proceso de ejecucion.
//#define VERIFICAL_RESULTADOS_EN_CADA_PASO             true


// [Planificador]

// Cantidad maxima de pasos que puede tener un plan.
// Cuanto mas grande sea este numero, mas ciclos puede tardar el proceso de planificacion.
// Este valor es un compromiso entre performance y eficiencia.
#define PASOS_MAXIMOS_DE_PLAN           20

// El metodo de planificacion puede encontrar varios planes, y de ellos elige el mejor.
// Si se hace seleccionar TODOS los posibles planes, puede tardar demasiado.
// Una opcion es determinar una cantidad maxima de posibles planes que se pueden testear.
// Este valor es un compromiso entre performance y eficiencia.
// Poner INFINITO si se desea deshabilitar esta opcion.
#define PLANES_MAXIMOS_TESTEADOS        10

// Es la minima relacion P/K que puede tener una teoria para considerarse como aceptable.
#define TOLERANCIA                                      0.75


// [Heuristicas]

// Cantidad de ciclos que se recuerda una teoria.
// Poner INFINITO si se desea deshabilitar esta opcion.
#define CICLOS_DE_MEMORIA                       10




bool incluye_a (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;



class CTeoria;
std::ostream& operator<< (std::ostream& os, const CTeoria& t);

// CTeoria
class CTeoria
{
public:

        std::string             nombre ;

        // Condiciones iniciales de la teoria.
        // Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.
        // Las condiciones se concatenan con un operador &&
        CIndiceMagico<t_dato>   datos_iniciales ;

        // La funcion que se debe ejecutar para hacer valer la teoria.
        std::string funcion ;
        // TODO std::string accion; Debería ser el nombre de la acción que va a realizar el BREVE

        // Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial
        CIndiceMagico<t_dato>   datos_finales ;

public:
        CTeoria()
        {
                nombre = "" ;
                funcion = "" ;
                k = 1 ;
                p = 1 ;
        }

        CTeoria(const std::string& ini_nombre, 
                const std::string& ini_funcion,
                        unsigned long ini_k,
                        unsigned long ini_p)
        {
                nombre = ini_nombre ;
                funcion = ini_funcion ;
                k = ini_k ;
                p = ini_p ;
        }

public: 
        // Cantidad de veces que se probo la teoria.
        unsigned long                   k ;

        // Cantidad de veces que se probo la teoria y resulto correcta.
        unsigned long                   p ;

        // Cantidad de ciclos ocurridos desde que se creo la teoria.
        // Este parametro se usa para quitarle memoria al SA.
        unsigned long                   ciclos ;

} ;

inline
std::ostream& operator<< (std::ostream& os, const CTeoria& t)
{
        return os << "CTeoria(nombre=" << t.nombre << ", funcion=" << t.funcion
                << ", p=" << t.p << ", k=" << t.k << /*", ciclos=" << t.ciclos <<*/ ")";
//              << "):\n\tdatos_iniciales:\n" << t.datos_iniciales
//              << "\tdatos_finales:\n" << t.datos_finales << "\n";
}


// CEntorno
class CEntorno
{
public:
        CIndiceMagico<t_dato>   datos ;

public:
//      CEntorno() { this->inicializar() ; }

public:
        // Inicializar los datos
        virtual void inicializar() {} ;

        // Actualizar los datos
        virtual void actualizar() {} ;

        // Destructor
        virtual ~CEntorno() {}
} ;



// CSistemaAutonomo
class CSistemaAutonomo
{
public:
        // El entono en el que se mueve el SA.
        CEntorno*                       p_entorno ;

        // Datos finales a utilizar al hacer
        CIndiceMagico<t_dato>           m_datos_finales;

        // Las teorias que tiene el SA.
        CIndiceMagico<CTeoria*>         teorias ;

public:
        // Constructor
        CSistemaAutonomo(): p_entorno(new CEntorno) {}

        // Destructor
        ~CSistemaAutonomo()
        {
                delete p_entorno;
                for (unsigned i = 0; i < teorias.count(); ++i)
                        delete teorias[i];
        }

        // Genera un nuevo plan
        void plan();

        // Indica si hay una teoria mas para ejecutar
        bool has_next_theory();

        // Obtiene la próxima teoría del plan actual
        CTeoria* get_next_theory();

        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool validate_theory(CTeoria*) ;

//protected:
        // Retorna true si los valores de la condicion coinciden con los valores del entorno.
        bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;

        // plan actual
        CIndiceMagico<CTeoria*> m_plan;

        // teoria actual
        CIndiceMagico<CTeoria*>::iterator curr_theory;

protected: 

        // Heuristica de observacion.
        //      Segun la teoria que se ejecuto, se crea una nueva teoria con TODOS/ALGUNOS valores actuales del entorno como condicion_final.
        void heuristca_observacion(CTeoria&) ;

        // Heuristica de correccion por retraccion.
        //      Si una teoria no se verifico como correcta, se crea una nueva quitandole las condiciones_finales que no se verifican.
        void heuristca_retraccion(CTeoria&) ;

        //Heuristica de generalizacion.
        // Si dentro de las teorias se encuentra unaque solo difiera de los datos del entorno en una condicíon inicial => se agrega una nueva teoria igual pero con ANY en esa condicion.
        void heuristca_generalizacion(CTeoria&);

public:

        
        void planificar (CIndiceMagico<t_dato>& datos_iniciales,
                        CIndiceMagico<t_dato>&  datos_finales,
                        CIndiceMagico<CTeoria*>& plan,
                        double&         p,
                        unsigned long   numero_de_llamada=0) ;


        // Ejecuta una serie de pasos.
        // Retorna true si se alcanza la condicion final.
//      bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
} ;



#endif