--- /dev/null
+
+CXXFLAGS=-Wall -g
+
+targets=test
+
+all: $(targets)
+test: main.o sistemaautonomo.o
+ $(CXX) $(LDFLAGS) -o test *.o
+
+clean:
+ $(RM) -fv *.o $(target)
+
+depend:
+ makedepend -- $(CFLAGS) -- *.cpp
+
#include <string>
+#include <map>
#include <iostream>
public:
CIndiceMagico()
{
- using std::cerr;
- using std::endl;
m_cant = 0 ;
m_nombres = (std::string*)calloc(sizeof(std::string), MAX_ELEMENTOS) ;
m_datos = (T*)calloc(sizeof(m_datos), MAX_ELEMENTOS) ;
if (!m_nombres)
- cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres." << endl ;
+ std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres.\n";
if (!m_datos)
- cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos." << endl ;
+ std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos.\n";
}
void add(CIndiceMagico<T>& indice)
{
- for (int i=0; i<indice.m_cant; i++)
- add(indice.m_nombres[i], indice.m_datos[i]) ;
+ for (unsigned i=0; i<indice.m_cant; i++)
+ add(indice.m_nombres[i].c_str(), indice.m_datos[i]) ;
}
bool exist(const char* nombre)
{
- for (int i=0; i<m_cant; i++)
+ for (unsigned i=0; i<m_cant; i++)
if (m_nombres[i]==nombre)
return true ;
//POS: Retorna el elemento.
T& find(const char* nombre)
{
- int i;
+ unsigned i;
for (i=0; i<m_cant && m_nombres[i]!=nombre; i++) ;
return m_datos[i] ;
}
void set_val(const std::string nombre, T valor)
{
- for (int i=0; i<m_cant; i++)
+ for (unsigned i=0; i<m_cant; i++)
if (m_datos[i]!=valor)
m_datos[i] ;
}
void remove(const unsigned long index)
{
- for (int i=index+1; i<m_cant; i++)
+ for (unsigned i=index+1u; i<m_cant; i++)
{
m_nombres[i-1] = m_nombres[i] ;
m_datos[i-1] = m_datos[i] ;
void remove(const char* nombre)
{
bool exito = false ;
- int i;
+ unsigned i;
for (i=0; !exito && i<m_cant; i++)
exito = m_nombres[i]==nombre ;
+
#include "main.h"
+#include <iostream>
//
-double CMiEntorno::AvanzarX()
+double AvanzarX(CEntorno& e)
{
avanzo_en_x = true ;
return 0 ;
}
-double CMiEntorno::AvanzarY()
+double AvanzarY(CEntorno& e)
{
avanzo_en_y = true ;
return 0 ;
}
-double CMiEntorno::AvanzarZ()
+double AvanzarZ(CEntorno& e)
{
avanzo_en_z = true ;
return 0 ;
}
-CMiEntorno::CMiEntorno():
- avanzo_en_x(true), avanzo_en_y(true), avanzo_en_z(true)
+//
+void CMiEntorno::inicializar()
{
// Inicializo el Entorno
- datos.add("robot.avanzo_en_x", 1) ;
- datos.add("robot.avanzo_en_y", 1) ;
- datos.add("robot.avanzo_en_z", 1) ;
+ datos.add("robot.avanzo_en_x", 0) ;
+ datos.add("robot.avanzo_en_y", 0) ;
+ datos.add("robot.avanzo_en_z", 0) ;
datos.add("robot.sensor_1", 0) ;
datos.add("robot.sensor_2", 0) ;
}
-struct CMiTeoria1: CTeoria< CMiEntorno >
-{
- CMiTeoria1(CMiEntorno& e):
- CTeoria< CMiEntorno >("Avanzar_X_1", 1, 1, e)
- {
- datos_iniciales.add ("robot.sensor_1", 0) ;
- datos_finales.add ("robot.avanzo_en_x", 1) ;
- }
- double funcion()
- {
- entorno.avanzo_en_x = true ;
- return 0 ;
- }
-};
-
-struct CMiTeoria2: CTeoria< CMiEntorno >
-{
- CMiTeoria2(CMiEntorno& e):
- CTeoria< CMiEntorno >("Avanzar_Y_1", 1, 1, e)
- {
- datos_iniciales.add ("robot.sensor_2", 0) ;
- datos_finales.add ("robot.avanzo_en_y", 1) ;
- }
- double funcion()
- {
- entorno.avanzo_en_y = true ;
- return 0 ;
- }
-};
-
-struct CMiTeoria3: CTeoria< CMiEntorno >
-{
- CMiTeoria3(CMiEntorno& e):
- CTeoria< CMiEntorno >("Avanzar_Z_1", 1, 1, e)
- {
- datos_iniciales.add ("robot.sensor_3", 0) ;
- datos_finales.add ("robot.avanzo_en_z", 1) ;
- }
- double funcion()
- {
- entorno.avanzo_en_z = true ;
- return 0 ;
- }
-};
+
//
int main(int argc, char** argv)
{
//
- CMiEntorno e ;
- CSistemaAutonomo< CMiEntorno > a(e) ;
+ CMiEntorno e ;
+ CSistemaAutonomo a ;
+ e.inicializar() ;
// Inicializo las teorias
- a.teorias.add("teoria1", new CMiTeoria1(e)) ;
- a.teorias.add("teoria2", new CMiTeoria2(e)) ;
- a.teorias.add("teoria3", new CMiTeoria3(e)) ;
+ CTeoria t1("Avanzar_X_1", &AvanzarX, 1, 1) ;
+ t1.datos_iniciales.add ("robot.sensor_1", 0) ;
+ t1.datos_iniciales.add ("robot.sensor_2", ANY) ;
+ t1.datos_iniciales.add ("robot.sensor_3", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_en_x", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
+ t1.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
+ t1.datos_finales.add ("robot.avanzo_en_x", 1) ;
+ t1.datos_finales.add ("robot.avanzo_en_y", 0) ;
+ t1.datos_finales.add ("robot.avanzo_en_z", 0) ;
+ t1.datos_finales.add ("robot.sensor_1", ANY) ;
+ t1.datos_finales.add ("robot.sensor_2", ANY) ;
+ t1.datos_finales.add ("robot.sensor_3", ANY) ;
+
+ CTeoria t2("Avanzar_Y_1", &AvanzarY, 1, 1) ;
+ t2.datos_iniciales.add ("robot.sensor_1", ANY) ;
+ t2.datos_iniciales.add ("robot.sensor_2", 0) ;
+ t2.datos_iniciales.add ("robot.sensor_3", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_en_x", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
+ t2.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
+ t2.datos_finales.add ("robot.avanzo_en_x", 0) ;
+ t2.datos_finales.add ("robot.avanzo_en_y", 1) ;
+ t2.datos_finales.add ("robot.avanzo_en_z", 0) ;
+ t2.datos_finales.add ("robot.sensor_1", ANY) ;
+ t2.datos_finales.add ("robot.sensor_2", ANY) ;
+ t2.datos_finales.add ("robot.sensor_3", ANY) ;
+
+ CTeoria t3("Avanzar_Z_1", &AvanzarZ, 1, 1) ;
+ t3.datos_iniciales.add ("robot.sensor_1", ANY) ;
+ t3.datos_iniciales.add ("robot.sensor_2", ANY) ;
+ t3.datos_iniciales.add ("robot.sensor_3", 0) ;
+ t3.datos_iniciales.add ("robot.avanzo_en_x", ANY) ;
+ t3.datos_iniciales.add ("robot.avanzo_en_y", ANY) ;
+ t3.datos_iniciales.add ("robot.avanzo_en_z", ANY) ;
+ t3.datos_finales.add ("robot.avanzo_en_x", 0) ;
+ t3.datos_finales.add ("robot.avanzo_en_y", 0) ;
+ t3.datos_finales.add ("robot.avanzo_en_z", 1) ;
+ t3.datos_finales.add ("robot.sensor_1", ANY) ;
+ t3.datos_finales.add ("robot.sensor_2", ANY) ;
+ t3.datos_finales.add ("robot.sensor_3", ANY) ;
+
+ a.teorias.add(t1.nombre.c_str(), t1) ;
+ a.teorias.add(t2.nombre.c_str(), t2) ;
+ a.teorias.add(t3.nombre.c_str(), t3) ;
+
+
+ // Inicializo el SA
+ a.p_entorno = (CEntorno*)(&e) ;
// Obtengo un plan
double p = 1 ;
- CIndiceMagico<CTeoria< CMiEntorno >* >* p_plan ;
+ CIndiceMagico<CTeoria> plan ;
CIndiceMagico<t_dato> datos_finales ;
+
+ datos_finales.add ("robot.avanzo_en_y", 1) ;
+
+ a.planificar (a.p_entorno->datos, datos_finales, plan, p) ;
- datos_finales.add ("robot.avanzo_en_x", 1) ;
+ for (unsigned i=0; i<plan.count(); i++)
+ std::cout << plan[i].nombre.c_str() << std::endl ;
- p_plan = a.new_plan(datos_finales, p) ;
- for (int i=0; i<p_plan->count(); i++)
- std::cout << (*p_plan)[i]->nombre << std::endl ;
+ // Ejecuto el plan
+ a.ejecutar(plan) ;
return 0 ;
+
#include "sistemaautonomo.h"
-// Entono especializado
-struct CMiEntorno : CEntorno
-{
-public:
- // Variables que definien el entorno REAL
- double sensor_1 ;
- double sensor_2 ;
- double sensor_3 ;
+// Variables que definien el entorno REAL
+static double sensor_1 = 0 ;
+static double sensor_2 = 0 ;
+static double sensor_3 = 0 ;
- bool avanzo_en_x ;
- bool avanzo_en_y ;
- bool avanzo_en_z ;
+static bool avanzo_en_x = false ;
+static bool avanzo_en_y = false ;
+static bool avanzo_en_z = false ;
- CMiEntorno() ;
- virtual void actualizar() ;
- // Funciones que usa el SA para modificar el entorno
- double AvanzarX();
- double AvanzarY();
- double AvanzarZ();
+// Funciones que usa el SA para modificar el entorno
+double AcanzarX(CEntorno& e);
+double AcanzarY(CEntorno& e);
+double AcanzarZ(CEntorno& e);
+
+
+// Entono especializado
+class CMiEntorno : CEntorno
+{
+public:
+ virtual void inicializar() ;
+ virtual void actualizar() ;
} ;
// Main
int main(int, char**) ;
-
//--------------------------------------------------------------------------------------------
//-- Funciones Auxiliares
+bool incluye_a (CIndiceMagico<t_dato>& a, CIndiceMagico<t_dato>& b)
+{
+ bool result = true ;
+ unsigned i ;
+ // Todas las variables de la condicion b deben estar en la condicion a
+ for (i=0; i<b.count() && result; i++)
+ result=a.exist(b.keys(i)) ;
+
+ // Todas las variables de la condicion a deben tener el mismo valor que en la condicion b
+ for (i=0; i<b.count() && result; i++)
+ result = b[i] == a.find(b.keys(i)) || b[i] == ANY || a.find(b.keys(i)) == ANY ;
+ //
+ return result ;
+}
-bool cumple_condiciones (CIndiceMagico<t_dato>& muestra, CIndiceMagico<t_dato>& patron)
-{
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::verificar_condicion(CIndiceMagico<t_dato>& datos)
+{
bool result = true ;
unsigned i ;
- for (i=0; i<muestra.count() && result; i++)
- result = (muestra[i] == patron.find(muestra.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 ;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_observacion(CTeoria& t)
+{
+ CTeoria nt ; //Nueva Teoria
+ unsigned i ;
+ std::string nombre ;
+
+ // 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]) ;
+
+ // 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]) ;
+
+
+ // Agrego la teoria
+ nombre = teorias.count() ;
+ teorias.add (nombre.c_str(), nt) ;
+
}
+
+//--------------------------------------------------------------------------------------------
+//--
+void CSistemaAutonomo::heurisitca_retraccion(CTeoria& t)
+{
+ CTeoria nt ; //Nueva Teoria
+ unsigned i ;
+
+ // Recorro la condicion final de la teoria
+ 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))
+ )
+ // Le asigno ANY
+ t.datos_finales[i] = ANY ;
+}
+
+
+//--------------------------------------------------------------------------------------------
+//--
+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 ;
+ double test_p ;
+ double max_p = 0 ;
+
+
+ if ( incluye_a(datos_iniciales, datos_finales) ) return ;
+
+ if ( numero_de_llamada > 7 ) return ;
+
+ 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_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) ;
+
+ if ( test_p>max_p )
+ if ( incluye_a(test_plan[test_plan.count()-1].datos_finales, datos_finales) )
+ {
+ max_p = test_p ;
+ new_plan.clear() ;
+ new_plan.add (test_plan) ;
+ }
+ }
+
+ if (max_p>0)
+ plan.add (new_plan) ;
+}
+
+
+
+//--------------------------------------------------------------------------------------------
+//--
+bool CSistemaAutonomo::ejecutar (CIndiceMagico<CTeoria>& plan)
+{
+ bool result = true ;
+ unsigned i ;
+ t_fnc(pFnc) ;
+ CTeoria t ;
+
+
+ for (i=0; i<plan.count() && result; i++)
+ {
+ t = plan[i] ;
+ pFnc = t.funcion;
+
+ // Ejecuto la funcion
+ (*pFnc)(*(this->p_entorno)) ;
+
+ // Incremento el K
+ t.k++ ;
+
+ // Actualizo los datos del entorno
+ this->p_entorno->actualizar() ;
+
+ // Veo si se verifica la condicion final
+ result = this->verificar_condicion(t.datos_finales) ;
+
+ // Si fallo la teoria
+ if (!result)
+ {
+ // Aplico heuristicas de correccion
+ this->heurisitca_retraccion(t) ;
+ }
+ else
+ {
+ t.p++ ;
+ }
+
+ // Aplico heuristicas de observacion
+ this->heurisitca_observacion(t) ;
+ }
+
+ //
+ return result ;
+}
#define __SISTEMAAUTONOMO__
#include "indicemagico.h"
+#include <math.h>
+#include <string>
+//#include <map>
+
// DEFINICIONES:
// ------------
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
-bool cumple_condiciones (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
+bool incluye_a (CIndiceMagico<t_dato>&, CIndiceMagico<t_dato>&) ;
// CTeoria
-template < typename E >
class CTeoria
{
public:
// 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.
+ double (*funcion)(CEntorno& e) ;
+
// Condiciones finales que deben cumplirsem luego de ejecutar la funcion final valiendo la condicion inicial
CIndiceMagico<t_dato> datos_finales ;
- // Entorno sobre el cual trabajar
- E& entorno;
-
public:
+ CTeoria()
+ {
+ nombre = "" ;
+ funcion = NULL ;
+ k = 1 ;
+ p = 1 ;
+ }
- CTeoria(const std::string& ini_nombre,
+ CTeoria(const char* ini_nombre,
+ double (*ini_funcion)(CEntorno& e),
unsigned long ini_k,
- unsigned long ini_p,
- E& e):
- nombre(ini_nombre),
- k(ini_k),
- p(ini_p),
- entorno(e)
- {}
+ unsigned long ini_p)
+ {
+ nombre = ini_nombre ;
+ funcion = ini_funcion ;
+ k = ini_k ;
+ p = ini_p ;
+ }
- // La funcion que se debe ejecutar para hacer valer la teoria.
- virtual double funcion() = 0;
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 ;
CIndiceMagico<t_dato> datos ;
public:
+// CEntorno() { this->inicializar() ; }
+
+public:
+ // Inicializar los datos
+ virtual void inicializar() {} ;
+
// Actualizar los datos
- virtual void actualizar() = 0 ;
+ virtual void actualizar() {} ;
+ // Destructor
virtual ~CEntorno() {}
} ;
// CSistemaAutonomo
-template < typename E >
class CSistemaAutonomo
{
public:
// El entono en el que se mueve el SA.
- E& entorno ;
+ CEntorno* p_entorno ;
// Las teorias que tiene el SA.
- CIndiceMagico< CTeoria< E >* > teorias ;
-
- ~CSistemaAutonomo()
- {
- for (int i = 0; i < teorias.m_cant; ++i)
- {
- delete teorias.m_datos[i];
- }
- }
-
+ CIndiceMagico<CTeoria> teorias ;
public:
// Retorna true si los valores de la condicion coinciden con los valores del entorno.
- bool verificar_condicion(CIndiceMagico<t_dato>& datos)
- {
- bool result = true ;
- unsigned i ;
-
-
- for (i=0; i<datos.count() && result; i++)
- result = datos[i] == this->p_entorno->datos.find(datos.keys(i)) ;
-
-
- //
- return result ;
- }
+ bool verificar_condicion(CIndiceMagico<t_dato>& datos) ;
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< E >&)
- {
- }
+ void heurisitca_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< E >&)
- {
- }
-
+ void heurisitca_retraccion(CTeoria&) ;
-protected:
- // Planificador: Se encaga de encontrar una serie de teorias que logren hacer
- // cumplir la condicion_final, partiendo de la condicion_inicial.
- // Parametros:
- // datos_iniciales: Forman la condicion inicial.
- // datos_finales: Forman la condicion final.
- CIndiceMagico<CTeoria< E >* >* planificar (
- CIndiceMagico<t_dato>& datos_iniciales,
- CIndiceMagico<t_dato>& datos_finales,
- CIndiceMagico<CTeoria< E >* >& plan,
- unsigned long numero_de_llamada,
- double& p) ;
-
public:
- CSistemaAutonomo(E& e): entorno(e) {}
-
- CIndiceMagico<CTeoria< E >* >* new_plan(CIndiceMagico< t_dato >& datos_finales, double& p)
- {
- CIndiceMagico<CTeoria< E >* > plan ;
- return planificar(entorno.datos, datos_finales, plan, 0, p) ;
- }
+
+ 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< E > >& plan) ;
+ bool ejecutar (CIndiceMagico<CTeoria>& plan) ;
} ;
-//--------------------------------------------------------------------------------------------
-//-- PROBAR BIEN
-template < typename E >
-CIndiceMagico< CTeoria< E >* >* CSistemaAutonomo< E >::planificar (
- CIndiceMagico< t_dato >& datos_iniciales,
- CIndiceMagico< t_dato >& datos_finales,
- CIndiceMagico< CTeoria< E >* >& plan,
- unsigned long numero_de_llamada,
- double& p)
-{
- unsigned i ;
- double nuevo_p ;
- double max_p = 0 ;
- CIndiceMagico< CTeoria< E >* >* p_nuevo_plan ;
- CIndiceMagico< CTeoria< E >* >* pResult = NULL ;
- CIndiceMagico< CIndiceMagico< CTeoria< E >* > > planes ;
-
-
- for (i=0; i<this->teorias.count(); i++)
- {
- // Si la teoria cumple la condicion inicial
- if ( cumple_condiciones(this->teorias[i]->datos_iniciales, datos_iniciales) )
- {
- p_nuevo_plan = new CIndiceMagico< CTeoria< E >* > ;
-
- nuevo_p = ( p + ((double)this->teorias[i]->p) / ((double)this->teorias[i]->k) ) / 2 ;
-
- // Agrego la teoria al plan
- p_nuevo_plan->add (this->teorias[i]->nombre.c_str(), this->teorias[i]) ;
-
- if (numero_de_llamada<PASOS_MAXIMOS_DE_PLAN)
- {
- // Pero si no cumple con la condicion final
- if ( !cumple_condiciones(datos_finales, this->teorias[i]->datos_finales) )
- {
- planificar (this->teorias[i]->datos_finales,
- datos_finales,
- *p_nuevo_plan,
- numero_de_llamada+1,
- nuevo_p) ;
- }
- }
-
-
- // Si cumple con la condicion final
- if (nuevo_p>max_p)
- {
- if ( cumple_condiciones(datos_finales, (*p_nuevo_plan)[p_nuevo_plan->count()-1]->datos_finales) )
- {
- max_p = nuevo_p ;
-
- if (pResult) delete pResult ;
-
- pResult = p_nuevo_plan ;
- }
- }
- }
- }
-
- //
- return pResult ;
-}
-
-
-//--------------------------------------------------------------------------------------------
-//--
-template < typename E >
-bool CSistemaAutonomo< E >::ejecutar (CIndiceMagico<CTeoria< E > >& plan)
-{
- bool result = true ;
- int i ;
- CTeoria< E > t ;
-
-
- for (i=0; i<plan.count() && result; i++)
- {
- t = plan[i] ;
-
- // Ejecuto la funcion
- t.funcion() ;
-
- // Incremento el K
- t.k++ ;
-
- // Actualizo los datos del entorno
- this->p_entorno->actualizar() ;
-
- // Veo si se verifica la condicion final
- result = this->verificar_condicion(t.datos_finales) ;
-
- // Si fallo la teoria
- if (!result)
- {
- // Aplico heuristicas de correccion
- this->heurisitca_retraccion(t) ;
- }
- else
- {
- t.p++ ;
- }
-
- // Aplico heuristicas de observacion
- this->heurisitca_observacion(t) ;
- }
-
- //
- return result ;
-}
-
-
#endif
projects / z.facultad / 75.68 / celdas.git / commitdiff