#include "indicemagico.h"
#include <math.h>
#include <string>
-//#include <map>
+#include <iostream>
// DEFINICIONES:
#define ANY -3000000
-#define t_fnc(name) double (*name)(CEntorno&)
+//#define t_fnc(name) double (*name)(CEntorno&)
#define INFINITO 9999999 //CORREGIR: Poner aca el numero maximo que puede tomar un unsigend long
// Precision en la comparacion de atributos.
// Poner en 0 si se quiere hacer la comparacion exacta.
-#define PRECISION 0.50000
+#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.
+class CTeoria;
+std::ostream& operator<< (std::ostream& os, const CTeoria& t);
// CTeoria
class CTeoria
{
public:
- std::string nombre ;
+ std::string nombre ;
// Condiciones iniciales de la teoria.
// Cada condicion se representa como un par (clave, valor), que se leen como clave=valor +/- PRECISION.
CIndiceMagico<t_dato> datos_iniciales ;
// La funcion que se debe ejecutar para hacer valer la teoria.
- double (*funcion)(CEntorno& e) ;
+ 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 ;
CTeoria()
{
nombre = "" ;
- funcion = NULL ;
+ funcion = "" ;
k = 1 ;
p = 1 ;
}
- CTeoria(const char* ini_nombre,
- double (*ini_funcion)(CEntorno& e),
+ CTeoria(const std::string& ini_nombre,
+ const std::string& ini_funcion,
unsigned long ini_k,
unsigned long ini_p)
{
p = ini_p ;
}
+//private:
+ CTeoria(const CTeoria& t):
+ nombre(t.nombre),
+ datos_iniciales(t.datos_iniciales),
+ funcion(t.funcion),
+ datos_finales(t.datos_finales),
+ k(t.k),
+ p(t.p)
+ {
+ std::cout << "-----> CTeoria::operator=(" << t << ") <-----\n";
+ }
+ CTeoria& operator= (const CTeoria& t)
+ {
+ std::cout << "-----> " << *this << "::operator=(" << t << ") <-----\n";
+ nombre = t.nombre;
+ funcion = t.funcion;
+ k = t.k;
+ p = t.p;
+ datos_iniciales = t.datos_iniciales;
+ datos_finales = t.datos_finales;
+ return *this;
+ }
+
public:
// Cantidad de veces que se probo la teoria.
} ;
+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
{
public:
// El entono en el que se mueve el SA.
- CEntorno* p_entorno ;
+ CEntorno* p_entorno ;
+
+ // Datos finales a utilizar al hacer
+ CIndiceMagico<t_dato> m_datos_finales;
// Las teorias que tiene el SA.
- CIndiceMagico<CTeoria> teorias ;
+ 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 heurisitca_observacion(CTeoria&) ;
+ 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 heurisitca_retraccion(CTeoria&) ;
+ 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 heurisitca_generalizacion(CTeoria&);
+ 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) ;
+ 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) ;
-
-
+// bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
} ;
projects / z.facultad / 75.68 / celdas.git / blobdiff