//
void CMiEntorno::inicializar()
{
+ // Inicializo el Entorno
+ datos.add("robot.sensor_adelante", 1) ;
+ datos.add("robot.sensor_atras", 0) ;
+ datos.add("robot.sensor_derecha", 0) ;
+ datos.add("robot.sensor_izquierda", 0) ;
+ datos.add("robot.avanzo_adelante", 0) ;
+ datos.add("robot.avanzo_atras", 0) ;
+ datos.add("robot.avanzo_derecha", 0) ;
+ datos.add("robot.avanzo_izquierda", 0) ;
+/*
// Inicializo el Entorno
datos.add("robot.avanzo_en_x", 0) ;
// old datos.add("robot.avanzo_en_y", 0) ;
datos.add("robot.sensor_2", 0) ;
datos.add("robot.sensor_3", 0) ;
datos.add("robot.sensor_4", 0) ; // new
+*/
}
void CMiEntorno::actualizar()
{
+ datos.find("robot.avanzo_adelante") = 0 ;
+ datos.find("robot.avanzo_atras") = 0 ;
+ datos.find("robot.avanzo_derecha") = 0 ;
+ datos.find("robot.avanzo_izquierda") = 0 ;
+ datos.find("robot.sensor_adelante") = 0 ;
+ datos.find("robot.sensor_atras") = 0 ;
+ datos.find("robot.sensor_derecha") = 0 ;
+ datos.find("robot.sensor_izquierda") = 0 ;
+
+/*
datos.find("robot.sensor_1") = sensor_1 ;
datos.find("robot.sensor_2") = sensor_2 ;
datos.find("robot.sensor_3") = sensor_3 ;
datos.find("robot.avanzo_en_x") = avanzo_en_x?1:0 ;
datos.find("robot.avanzo_en_y") = avanzo_en_y?1:0 ;
datos.find("robot.avanzo_en_z") = avanzo_en_z?1:0 ;
-
+*/
}
t3.datos_finales.add ("robot.sensor_3", ANY) ;
*/
+/*
// Inicializo las teorias
CTeoria t1("Avanzar_X_1", "AvanzarX", 1, 1) ;
t1.datos_iniciales.add ("robot.sensor_1", ANY) ;
t2.datos_finales.add ("robot.sensor_3", ANY) ;
t2.datos_finales.add ("robot.sensor_4", ANY) ;
+
a.teorias.add(t1.nombre.c_str(), t1) ;
a.teorias.add(t2.nombre.c_str(), t2) ;
// OLD a.teorias.add(t3.nombre.c_str(), t3) ;
std::cout << " .datos_finales:\n" << t2.datos_finales << "\n";
#endif // DEBUG
-
+*/
+
+ // Inicializo las teorias
+ CTeoria t1("Avanzar", "avanzar", 1, 1) ;
+ t1.datos_iniciales.add ("robot.sensor_adelante", 0) ;
+ t1.datos_iniciales.add ("robot.sensor_atras", ANY) ;
+ t1.datos_iniciales.add ("robot.sensor_derecha", ANY) ;
+ t1.datos_iniciales.add ("robot.sensor_izquierda", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_adelante", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_atras", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_derecha", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ;
+ t1.datos_finales.add ("robot.sensor_adelante", ANY) ;
+ t1.datos_finales.add ("robot.sensor_atras", ANY) ;
+ t1.datos_finales.add ("robot.sensor_derecha", ANY) ;
+ t1.datos_finales.add ("robot.sensor_izquierda", ANY) ;
+ t1.datos_finales.add ("robot.avanzo_adelante", 1) ;
+ t1.datos_finales.add ("robot.avanzo_atras", 0) ;
+ t1.datos_finales.add ("robot.avanzo_derecha", 0) ;
+ t1.datos_finales.add ("robot.avanzo_izquierda", 0) ;
+
+
+ CTeoria t2("Retroceder", "retroceder", 1, 1) ;
+ t2.datos_iniciales.add ("robot.sensor_adelante", ANY) ;
+ t2.datos_iniciales.add ("robot.sensor_atras", 0) ;
+ t2.datos_iniciales.add ("robot.sensor_derecha", ANY) ;
+ t2.datos_iniciales.add ("robot.sensor_izquierda", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_adelante", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_atras", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_derecha", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ;
+ t2.datos_finales.add ("robot.sensor_adelante", ANY) ;
+ t2.datos_finales.add ("robot.sensor_atras", ANY) ;
+ t2.datos_finales.add ("robot.sensor_derecha", ANY) ;
+ t2.datos_finales.add ("robot.sensor_izquierda", ANY) ;
+ t2.datos_finales.add ("robot.avanzo_adelante", 0) ;
+ t2.datos_finales.add ("robot.avanzo_atras", 1) ;
+ t2.datos_finales.add ("robot.avanzo_derecha", 0) ;
+ t2.datos_finales.add ("robot.avanzo_izquierda", 0) ;
+
+
+ CTeoria t3("Derecha", "derecha", 1, 1) ;
+ t3.datos_iniciales.add ("robot.sensor_adelante", ANY) ;
+ t3.datos_iniciales.add ("robot.sensor_atras", ANY) ;
+ t3.datos_iniciales.add ("robot.sensor_derecha", 0) ;
+ t3.datos_iniciales.add ("robot.sensor_izquierda", ANY) ;
+ t3.datos_iniciales.add ("robot.avanzo_adelante", ANY) ;
+ t3.datos_iniciales.add ("robot.avanzo_atras", ANY) ;
+ t3.datos_iniciales.add ("robot.avanzo_derecha", ANY) ;
+ t3.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ;
+ t3.datos_finales.add ("robot.sensor_adelante", ANY) ;
+ t3.datos_finales.add ("robot.sensor_atras", ANY) ;
+ t3.datos_finales.add ("robot.sensor_derecha", ANY) ;
+ t3.datos_finales.add ("robot.sensor_izquierda", ANY) ;
+ t3.datos_finales.add ("robot.avanzo_adelante", 0) ;
+ t3.datos_finales.add ("robot.avanzo_atras", 0) ;
+ t3.datos_finales.add ("robot.avanzo_derecha", 1) ;
+ t3.datos_finales.add ("robot.avanzo_izquierda", 0) ;
+
+
+ CTeoria t4("Eludir.1", "derecha", 1, 1) ;
+ t4.datos_iniciales.add ("robot.sensor_adelante", 1) ;
+ t4.datos_iniciales.add ("robot.sensor_atras", ANY) ;
+ t4.datos_iniciales.add ("robot.sensor_derecha", 0) ;
+ t4.datos_iniciales.add ("robot.sensor_izquierda", ANY) ;
+ t4.datos_iniciales.add ("robot.avanzo_adelante", ANY) ;
+ t4.datos_iniciales.add ("robot.avanzo_atras", ANY) ;
+ t4.datos_iniciales.add ("robot.avanzo_derecha", ANY) ;
+ t4.datos_iniciales.add ("robot.avanzo_izquierda", ANY) ;
+ t4.datos_finales.add ("robot.sensor_adelante", 0) ;
+ t4.datos_finales.add ("robot.sensor_atras", ANY) ;
+ t4.datos_finales.add ("robot.sensor_derecha", ANY) ;
+ t4.datos_finales.add ("robot.sensor_izquierda", ANY) ;
+ t4.datos_finales.add ("robot.avanzo_adelante", 0) ;
+ t4.datos_finales.add ("robot.avanzo_atras", ANY) ;
+ t4.datos_finales.add ("robot.avanzo_derecha", 1) ;
+ t4.datos_finales.add ("robot.avanzo_izquierda", ANY) ;
+
+
+ a.teorias.add(t1.nombre, &t1) ;
+ a.teorias.add(t2.nombre, &t2) ;
+ a.teorias.add(t3.nombre, &t3) ;
+ a.teorias.add(t4.nombre, &t4) ;
+#ifdef DEBUG
+ std::cout << "Agrega teoria: " << t1 << "\n";
+ std::cout << "\tdatos_iniciales:\n" << t1.datos_iniciales << "\n";
+ std::cout << "\tdatos_finales:\n" << t1.datos_finales << "\n";
+ std::cout << "Agrega teoria: " << t2 << "\n";
+ std::cout << "\tdatos_iniciales:\n" << t2.datos_iniciales << "\n";
+ std::cout << "\tdatos_finales:\n" << t2.datos_finales << "\n";
+ std::cout << "Agrega teoria: " << t3 << "\n";
+ std::cout << "\tdatos_iniciales:\n" << t3.datos_iniciales << "\n";
+ std::cout << "\tdatos_finales:\n" << t3.datos_finales << "\n";
+ std::cout << "Agrega teoria: " << t4 << "\n";
+ std::cout << "\tdatos_iniciales:\n" << t4.datos_iniciales << "\n";
+ std::cout << "\tdatos_finales:\n" << t4.datos_finales << "\n";
+#endif // DEBUG
+
// Inicializo el SA
delete a.p_entorno;
a.p_entorno = e;
-
// Obtengo un plan
CIndiceMagico<t_dato> datos_finales;
- a.m_datos_finales.add ("robot.avanzo_en_x", 1) ;
- a.plan();
- for (unsigned i=0; i<a.m_plan.count(); i++)
- std::cout << a.m_plan[i].nombre.c_str() << std::endl ;
-
- if (a.has_next_theory())
- {
- CTeoria* t = a.get_next_theory();
- if (a.validate_theory(t))
- std::cout << "Valida\n";
- }
-
-// datos_finales.add ("robot.avanzo_en_x", 1) ;
+ a.m_datos_finales.add ("robot.avanzo_adelante", 1) ;
+ //a.m_datos_finales.add ("robot.avanzo_en_x", 1) ;
-// a.planificar (a.p_entorno->datos, datos_finales, plan, p) ;
+ for (int i = 0; i < 3; ++i)
+ {
-// for (unsigned i=0; i<plan.count(); i++)
-// std::cout << plan[i].nombre.c_str() << std::endl ;
+ std::cout << "Teorias:\n" << a.teorias << "\n";
+ a.plan();
- // Ejecuto el plan
-// a.ejecutar(plan) ;
+ while (a.has_next_theory())
+ {
+ CTeoria* t = a.get_next_theory();
+ if (a.validate_theory(t))
+ {
+ std::cout << "Valida\n";
+ }
+ else
+ {
+ std::cout << "No valida, planificamos de nuevo\n";
+ break;
+ }
+ }
+ }
return 0 ;
}
// Variables que definien el entorno REAL
+/*
static double sensor_1 = 0 ;
static double sensor_2 = 0 ;
static double sensor_3 = 0 ;
static bool avanzo_en_x = false ;
static bool avanzo_en_y = false ;
static bool avanzo_en_z = false ;
-
+*/
// Funciones que usa el SA para modificar el entorno
double AcanzarX(CEntorno& e);
{\r
CSistemaAutonomo* sa = (CSistemaAutonomo*) BRPOINTER(args);\r
CTeoria* t = (CTeoria*) BRPOINTER(args+1);\r
- sa->teorias.add(t->nombre.c_str(), *t);\r
+ sa->teorias.add(t->nombre, t);\r
#ifdef DEBUG\r
std::cout << "Agrega teoria " << t->nombre << ":\n";\r
std::cout << " .datos_iniciales:\n" << t->datos_iniciales << "\n";\r
#include "sistemaautonomo.h"
+#include <sstream>
#ifdef DEBUG
#include <iostream>
double p = 1.0;
m_plan.clear();
#ifdef DEBUG
- std::cout << "entorno:\n" << p_entorno->datos << "\n";
- std::cout << "datos finales:\n" << m_datos_finales << "\n";
+ std::cout << "SA: Planificando...\n";
+ std::cout << "SA: \tentorno:\n" << p_entorno->datos << "\n";
+ std::cout << "SA: \tdatos finales:\n" << m_datos_finales << "\n";
#endif // DEBUG
planificar(p_entorno->datos, m_datos_finales, m_plan, p);
#ifdef DEBUG
- std::cout << "plan:\n" << m_plan << "\n";
+ std::cout << "SA: \tplan:\n" << m_plan << "\n";
#endif // DEBUG
curr_theory = m_plan.begin();
#ifdef DEBUG
if (curr_theory == m_plan.end())
- std::cout << "No hay teorías\n";
+ std::cout << "SA: No hay teorías\n";
else
- std::cout << "curr teoria: " << &*curr_theory << "=" << curr_theory->nombre << "\n";
+ std::cout << "SA: curr teoria: " << **curr_theory << "\n";
#endif // DEBUG
}
}
else
{
- return &*(curr_theory++);
+ return *(curr_theory++);
}
}
{
bool result ;
+ // Aumento k (cantidad de veces que se probó la teoría
+ ++t->k;
+
+ // Verifico
result = verificar_condicion(t->datos_finales) ;
+ // Si se ejecuto bien la teoria incremento el p
+ if (result) t->p++ ;
// Si fallo la teoria
if (!result)
{
+ // Aplico heuristicas de observacion
+#ifdef DEBUG
+ std::cout << "SA: No verifica, aplicando heuristicas...\n";
+ std::cout << "SA: Aplicando heuristica de observacion\n";
+#endif // DEBUG
+ this->heuristca_observacion(*t) ;
+#ifdef DEBUG
+ std::cout << "SA: Aplicando heuristica de generalizacion\n";
+#endif // DEBUG
+ this->heuristca_generalizacion(*t);
+#ifdef DEBUG
+ std::cout << "SA: Aplicando heuristica de retraccion\n";
+#endif // DEBUG
// Aplico heuristicas de correccion
- this->heurisitca_retraccion(*t) ;
- }
- else
- {
- t->p++ ;
+ this->heuristca_retraccion(*t) ;
}
- // Aplico heuristicas de observacion
- this->heurisitca_observacion(*t) ;
- this->heurisitca_generalizacion(*t);
-
return result;
}
bool result = true ;
unsigned i ;
+ for (i = 0; i < datos.count() && result; i++)
+ result = (datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i)));
- for (i=0; i<datos.count() && result; i++)
- result = datos[i] == ANY || datos[i] == this->p_entorno->datos.find(datos.keys(i)) ;
-
-
- //
return result ;
}
-
+std::string make_nombre(const std::string& n, char mod, unsigned i)
+{
+ std::ostringstream oss;
+ oss << n << "-" << mod << i;
+ return oss.str();
+}
//--------------------------------------------------------------------------------------------
//--
-void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
+void CSistemaAutonomo::heuristca_observacion(CTeoria& t)
{
- CTeoria nt ; //Nueva Teoria
- unsigned i ;
- std::string nombre ;
-
+ CTeoria* pnt = new CTeoria ; //Nueva Teoria
+ CTeoria& nt = *pnt;
+
// Le agrego los datos iniciales tal cual estaban antes
- for (i=0; i<t.datos_iniciales.count(); i++)
- nt.datos_iniciales.add(t.datos_iniciales.keys(i), t.datos_iniciales[i]) ;
+ nt.datos_iniciales = t.datos_iniciales;
// Le agrego todas las condiciones del entorno como condicion final
- for (i=0; i<this->p_entorno->datos.count(); i++)
- nt.datos_finales.add(this->p_entorno->datos.keys(i), this->p_entorno->datos[i]) ;
+ nt.datos_finales = p_entorno->datos;
+ // Le cargo nombre y funcion (queda con k=1 y p=1)
+ nt.nombre = make_nombre(t.nombre, 'o', teorias.count());
+ nt.funcion = t.funcion;
// Agrego la teoria
- nombre = teorias.count() ;
- teorias.add (nombre.c_str(), nt) ;
-
+ teorias.add (nt.nombre, pnt) ;
+#ifdef DEBUG
+ std::cout << "SA: Se agrego una nueva teoria: " << nt << " basada en " << t << "\n";
+ std::cout << "SA: \tdatos_iniciales:\n" << nt.datos_iniciales << "\n";
+ std::cout << "SA: \tdatos_finales:\n" << nt.datos_finales << "\n";
+#endif // DEBUG
+
}
//--------------------------------------------------------------------------------------------
// Si las condiciones finales del entorno son iguales a las condiciones finales de alguna teoria y
// solo una condicion inicial es distinta => agrego una nueva teoría igual (a la q cumple los requisitos
// anteriormente detallados) pero tomando ANY en el valor de entrada en el cual difieren.
-void CSistemaAutonomo::heurisitca_generalizacion(CTeoria& t)
+void CSistemaAutonomo::heuristca_generalizacion(CTeoria& t)
{
- CTeoria nt ; //Nueva Teoria
unsigned i ;
int count = 0;
unsigned k = 0;
cantidadTeorias = this->teorias.count();
- for (i=0; i<cantidadTeorias; i++)
+ for (i = 0; i < cantidadTeorias; i++)
{
- for (k=0; k<this->teorias[i].datos_finales.count(); k++)
+ for (k = 0; k < this->teorias[i]->datos_finales.count(); k++)
{
//me fijo si las condiciones finales de la teoria se corresponden con la del entorno.
- if((this->teorias[i].datos_finales[k] != ANY) && (this->p_entorno->datos.find(t.datos_finales.keys(k)) != ANY))
+ if ((this->teorias[i]->datos_finales[k] != ANY) && (this->p_entorno->datos.find(t.datos_finales.keys(k)) != ANY))
{
- if(this->teorias[i].datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k)))
+ if (this->teorias[i]->datos_finales[k] != this->p_entorno->datos.find(t.datos_finales.keys(k)))
{
count++;
}
}
}
- if(count == 0)
+ if (count == 0)
{ // si se corresponden (las condiciones finales son iguales) => me fijo si hay alguna condicion inicial q cambia.
- for (j=0; j<this->teorias[i].datos_iniciales.count(); j++)
+ for (j = 0; j < this->teorias[i]->datos_iniciales.count(); j++)
{
- if((this->teorias[i].datos_iniciales[j] != ANY) && (this->p_entorno->datos.find(t.datos_iniciales.keys(j)) != ANY))
+ if ((this->teorias[i]->datos_iniciales[j] != ANY) && (this->p_entorno->datos.find(t.datos_iniciales.keys(j)) != ANY))
{
- if(this->teorias[i].datos_iniciales[j] != this->p_entorno->datos.find(t.datos_iniciales.keys(j)))
+ if (this->teorias[i]->datos_iniciales[j] != this->p_entorno->datos.find(t.datos_iniciales.keys(j)))
{
posicionCambio = j;
count++;
}
}
}
- if(count == 1)
- {//si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia.
- nt = this->teorias[i];
- nt.datos_iniciales[posicionCambio] = ANY;
+ if (count == 1)
+ {
+ //si cambia solo una => creo una nueva teoria igual pero con ANY en la condicion q cambia.
+ CTeoria* nt = new CTeoria ; //Nueva Teoria
+ *nt = *this->teorias[i];
+ nt->datos_iniciales[posicionCambio] = ANY;
// Agrego la teoria
- nombreTeoria = teorias.count() ;
- teorias.add (nombreTeoria.c_str(), nt) ;
+ nt->nombre = make_nombre(t.nombre, 'g', teorias.count());
+ teorias.add (nt->nombre, nt) ;
+#ifdef DEBUG
+ std::cout << "SA: Se agrego una nueva teoria: " << *nt << " basada en " << *teorias[i] << "\n";
+ std::cout << "SA: \tdatos_iniciales:\n" << nt->datos_iniciales << "\n";
+ std::cout << "SA: \tdatos_finales:\n" << nt->datos_finales << "\n";
+#endif // DEBUG
}
}
posicionCambio = -1;
//--------------------------------------------------------------------------------------------
//--
-void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
+void CSistemaAutonomo::heuristca_retraccion(CTeoria& t)
{
- CTeoria nt ; //Nueva Teoria
unsigned i ;
+ unsigned modif = (unsigned)-1;
// Recorro la condicion final de la teoria
- for (i=0; i<t.datos_finales.count(); i++)
+ for (i = 0; i < t.datos_finales.count(); i++)
+ {
// Si el dato no coincidio con el del entorno, y no era ANY
if (t.datos_finales[i] != ANY &&
- t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i))
- )
+ t.datos_finales[i] != this->p_entorno->datos.find(t.datos_finales.keys(i)))
+ {
// Le asigno ANY
t.datos_finales[i] = ANY ;
+ modif = i;
+ }
+ }
+ if (modif != (unsigned)-1)
+ {
+ // Le cambio el nombre para indicar que fue modificada
+ t.nombre += "-r";
+#ifdef DEBUG
+ std::cout << "SA: Se modifica la teoria: " << t << ", el dato final '"
+ << t.datos_finales.keys(modif) << "' puede tomar ahora cualquier valor\n";
+#endif // DEBUG
+ }
}
//--------------------------------------------------------------------------------------------
//--
-void CSistemaAutonomo::planificar ( CIndiceMagico<t_dato>& datos_iniciales,
- CIndiceMagico<t_dato>& datos_finales,
- CIndiceMagico<CTeoria>& plan,
- double& p,
- unsigned long numero_de_llamada)
+void CSistemaAutonomo::planificar (CIndiceMagico<t_dato>& datos_iniciales,
+ CIndiceMagico<t_dato>& datos_finales,
+ CIndiceMagico<CTeoria*>& plan,
+ double& p,
+ unsigned long numero_de_llamada)
{
unsigned i;
- CIndiceMagico<CTeoria> test_plan ;
- CIndiceMagico<CTeoria> new_plan ;
+ CIndiceMagico<CTeoria*> test_plan ;
+ CIndiceMagico<CTeoria*> new_plan ;
double test_p ;
double max_p = 0 ;
if ( numero_de_llamada > 7 ) return ;
- for (i=0; i<teorias.count(); i++)
- if ( incluye_a(teorias[i].datos_iniciales, datos_iniciales) )
+ for (i = 0; i < teorias.count(); i++)
+ if ( incluye_a(teorias[i]->datos_iniciales, datos_iniciales) )
{
test_plan.clear() ;
- test_plan.add (teorias[i].nombre.c_str(), teorias[i]) ;
+ test_plan.add (teorias[i]->nombre, teorias[i]) ;
- test_p = p * ((double)teorias[i].p)/((double)teorias[i].k) ;
+ test_p = p * ((double)teorias[i]->p)/((double)teorias[i]->k) ;
- planificar(teorias[i].datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ;
+ planificar(teorias[i]->datos_finales, datos_finales, test_plan, test_p, numero_de_llamada+1) ;
if ( test_p>max_p )
- if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
+ if ( incluye_a(test_plan[test_plan.count()-1]->datos_finales, datos_finales) )
{
max_p = test_p ;
new_plan.clear() ;
if (!result)
{
// Aplico heuristicas de correccion
- this->heurisitca_retraccion(t) ;
+ this->heuristca_retraccion(t) ;
}
else
{
}
// Aplico heuristicas de observacion
- this->heurisitca_observacion(t) ;
- this->heurisitca_generalizacion(t);
+ this->heuristca_observacion(t) ;
+ this->heuristca_generalizacion(t);
}
//
#include "indicemagico.h"
#include <math.h>
#include <string>
-//#include <map>
+#include <iostream>
// DEFINICIONES:
+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.
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, CTeoria& t)
+std::ostream& operator<< (std::ostream& os, const CTeoria& t)
{
- return os << t.nombre << " > " << t.funcion;
+ 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";
}
CIndiceMagico<t_dato> m_datos_finales;
// Las teorias que tiene el SA.
- CIndiceMagico<CTeoria> teorias ;
+ CIndiceMagico<CTeoria*> teorias ;
public:
// Constructor
bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;
// plan actual
- CIndiceMagico<CTeoria> m_plan;
+ CIndiceMagico<CTeoria*> m_plan;
// teoria actual
- CIndiceMagico<CTeoria>::iterator curr_theory;
+ 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,
+ CIndiceMagico<CTeoria*>& plan,
double& p,
unsigned long numero_de_llamada=0) ;
projects / z.facultad / 75.68 / celdas.git / commitdiff