double hill_climbing(double nodo_inicial[10]) {
int i, j;
int k = 0;
double **vecinos;
double alfa = ((double)(rand() % 1000)) / 1000;
double nodo_actual[10], nodo_prox[10];
double prox_eval = -100000;
copiar_vector(10,nodo_actual,nodo_inicial);
srand(time(0));
while ( k < 100) {
vecinos = sucesores_hill(nodo_actual,alfa);
i = 0;
for ( i = 0 ; i < 20 ; i++ ) {
if (vecinos[i] == NULL) continue;
if ( evaluar(vecinos[i]) > prox_eval ) {
copiar_vector(10,nodo_prox,vecinos[i]);
prox_eval = evaluar(vecinos[i]);
}
}
if (prox_eval <= evaluar(nodo_actual)) {
alfa = ((double)(rand() % 1000)) / 1000;
} else copiar_vector(10,nodo_actual,nodo_prox);
k++;
}
for ( j = 0 ; j < 10 ; j++ ) printf("%.10lf ",nodo_actual[j]);
return evaluar(nodo_actual);
}
double simulatedAnnealing(int kmax, double ss[10]){
double s[10];
memcpy(s,ss,sizeof(double)*10);
int i;
double sb[10];
double sn[10];
double e = evaluar(s);
numeval++;
memcpy(sb,s,sizeof(double)*10);
double eb = e;
double en;
int k = 0;
while(k < kmax && e < 10){
getRandomNeighbor(s, sn);
en = evaluar(sn);
numeval++;
if(en > eb){
memcpy(sb,sn,sizeof(double)*10);
eb = en;
}
if(enfriamiento(e,en,temp(e,en)) > ((double)rand() / ((double)(RAND_MAX)+(double)(1)))){
memcpy(s,sn,sizeof(double)*10);
e = en;
}
k++;
}
memcpy(ss,sb,sizeof(double)*10);
return eb;
}
double hillClimbing(double x[10], double bsf[10]){
double currentNode[10];
memcpy(currentNode, x,sizeof(double)*10);
double neighbors[10][10];
int maxRange = 0;
double nextEval = -9999;
double nextNode[10];
double currentEval = evaluar(currentNode);
double temp;
int i =0;
while(numeval <= NUMEVAL){
getNeighbours(currentNode,neighbors);
nextEval = -99999;
int i = 0;
for(i = 0; i < 10; i++){
numeval++;
temp = evaluar(neighbors[i]);
if (temp > nextEval){
memcpy(nextNode,neighbors[i],sizeof(double)*10);
nextEval = temp;
}
}
if (nextEval <= currentEval){
memcpy(bsf,currentNode,sizeof(double)*10);
return currentEval;
}
memcpy(currentNode,nextNode,sizeof(double)*10);
currentEval = nextEval;
}
}
int evaluar(punteroExpresion expresion, punteroAsignaciones asignaciones){
switch(expresion->tipoNodo){
case T_NUMERO:
return expresion->infoNodo.numero;
break;
case T_OPERADOR:
switch(expresion->infoNodo.oper){
case O_SUMA:
return evaluar(expresion->expreIzq, asignaciones) + evaluar(expresion->expreDer, asignaciones);
break;
case O_RESTA:
return evaluar(expresion->expreIzq, asignaciones) - evaluar(expresion->expreDer, asignaciones);
break;
case O_MULTIPLICACION:
return evaluar(expresion->expreIzq, asignaciones) * evaluar(expresion->expreDer, asignaciones);
break;
case O_DIVISION:
return evaluar(expresion->expreIzq, asignaciones) / evaluar(expresion->expreDer, asignaciones);
break;
}
case T_ID:
return valorId(expresion->infoNodo.id, asignaciones);
break;
}
}
double simulated_anneling(double nodo_inicial[10], double Temp, double MaxIter, double MaxAccept) {
int i = 0;
int a = 0;
double *vecino, nodo_actual[10], delta, suerte;
double eval_actual = evaluar(nodo_inicial);
double alfa = 0.9;
double ro = 1.003;
double k = 0.0;
copiar_vector(10,nodo_actual,nodo_inicial);
srand(time(0));
while (i < 200) {
while (k < MaxIter && a < MaxAccept) {
vecino = sucesor_simul(nodo_actual);
delta = evaluar(vecino) - eval_actual;
if ( delta > 0 ) {
copiar_vector(10,nodo_actual,vecino);
eval_actual = evaluar(vecino);
a++;
} else {
suerte = (double)rand()/((double)(RAND_MAX)+(double)(1));
if (expo(delta/Temp) > suerte ) {
copiar_vector(10,nodo_actual,vecino);
eval_actual = evaluar(vecino);
a++;
}
}
k += 1;
}
Temp *= alfa;
MaxIter *= ro;
k = 0.0;
a = 0;
i++;
}
int j;
for ( j = 0 ; j < 10 ; j++ ) printf("%.10lf ",nodo_actual[j]);
return evaluar(nodo_actual);
}
double geneticAlgorithm(double bestA[10]){
srand(time(NULL));
double poblacion [1000][10];
double poblacionN [1000][10];
double parents[2][10];
double hijo [10];
double bestsofarP[10];
double resultN[10];
double bestsofar = -999;
double prevresult = -999;
double temp;
int repetidos = 0;
int j = 0;
int i = 0;
for(i = 0; i < 1000; i++) {
for(j = 0; j < 10; j++) {
poblacion[i][j] = (rand()%10 < 5 ? -1 : 1)*(double)rand() / ((double)(RAND_MAX)+(double)(1));
}
}
int k,n = 0;
double result = -999;
while(result < 9 && numeval <= NUMEVAL){
prevresult = result;
for(i = 0; i < 1000; i++){
getParents(poblacion,parents);
reproducir(parents[0],parents[1],hijo);
if(rand()%10 < 1){
mutar(hijo);
}
temp = evaluar(hijo);
numeval++;
if(temp > result){
result = temp;
memcpy(&resultN, &hijo, sizeof(double)*10);
}
memcpy(&poblacionN[i], &hijo,sizeof(double)*10);
}
memcpy(&poblacion,&poblacionN,sizeof(double)*10000);
if(result > bestsofar) {
repetidos = 0;
bestsofar = result;
memcpy(bestsofarP, resultN,sizeof(double)*10);
}else if(result == prevresult) {
if(repetidos == 5){
result = bestsofar;
break;
}
repetidos++;
}else if(result != prevresult) {
repetidos = 0;
}
printf("BestSoFar: %lf Prev: %lf, Result: %lf \n",bestsofar,prevresult,result);
}
memcpy(bestA,bestsofarP,sizeof(double)*10);
return result;
}
int main(int argc, char *argv[]){
printf("empezando \n");
int resultado = 0;
int conjExiste = 1;
char entornoBuffer[2000];
FILE *archCfg;
if (argc != 3) {
usage(argv[0]);
}
//archivo q contiene los conjuntos a evaluar
if ((archCfg = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "Evaluador: no pudo abrir archivo: %s \n",argv[1]);
}
printf("abriendo archivo \n");
int numConjunto = atoi(argv[2]); //numero de conjunto a evaluar
punteroConjuntos listaConjuntos = execEval(archCfg);
punteroConjunto conjunto = listaConjuntos->punConjunto;
//verificar si el archivo tiene conjuntos, de ser así busca y evalúa el indicado
if (!listaConjuntos){
fprintf(stderr,"Evaluador %d: no hay conjuntos para evaluar!! \n", numConjunto);
}
else{
int num = conjunto->numeroConjunto;
while (listaConjuntos != NULL && num != numConjunto){
listaConjuntos = listaConjuntos->punteroConjuntosSiguiente;
if(listaConjuntos == NULL){
conjExiste = 0;
fprintf(stderr, "Evaluador %d: No existe el conjunto %d \n", numConjunto, numConjunto);
}
else{
conjunto = listaConjuntos->punConjunto;
num = conjunto->numeroConjunto;
}
}
}
if (conjExiste){
while(1){
read(0,entornoBuffer,strlen(entornoBuffer));
fprintf(stdin, "Evaluador: entorno recibido: %s\n", entornoBuffer);
}
//me queda por obtener la lista de asignaciones para evaluarlas
punteroAsignaciones asignaciones = conjunto->asignaciones;
punteroAsignaciones entorno;
char *tmp;
strcpy(tmp, entornoBuffer);
entorno = (punteroAsignaciones)tmp;
while (asignaciones != NULL){
punteroAsignacion asignacion = asignaciones->punAsignacion;
resultado = evaluar(asignacion->expresion, entorno);
printf("Evaluador %d: El resultado de %s es: %d \n", numConjunto,asignacion->idAsignacion, resultado);
asignaciones = asignaciones->punteroAsignacionesSiguiente;
write(stdin, entornoBuffer, 2000);
}
}
}
int main()
{
int n;
float x;
printf("Ingrese cantidad de terminos : ");
scanf("%d",&n);
printf("Ingrese valor a evaluar : ");
scanf("%f",&x);
printf("Valor Evaluado : %f\n",evaluar(n,x));
}
int main(){
int n;
Stack s;
s=empty();
char c;
char posfija[100];
int largo=0;
int flag=0;
// Se pasa a posfija
while(1){
if(!flag) scanf("%c",&c);
else flag=0;
if(c=='\n' || c=='\0') break;
if(c=='('||c=='{'||c=='[') s=push(c,s);
else if(c==')' || c=='}' || c==']'){
char a=top(s);
while(a!='(' && a!='{' && a!='['){
posfija[largo++]=a;
s=pop(s); a=top(s);
}
s=pop(s);
}
else if(esOperando(c)==1){
posfija[largo++]=c;
scanf("%c",&c);
while(esOperando(c)){
if(c=='\n' || c=='\0'){
flag=1;
break;
}
posfija[largo++]=c;
scanf("%c",&c);
}
posfija[largo++]=',';
flag=1;
continue;
}
else if(esOperador(c)){
while(!isEmpty(s) && (prec(top(s))>= prec(c))){
posfija[largo++]=top(s);
s=pop(s);
}
s=push(c,s);
}
}
while(!isEmpty(s)){
posfija[largo++]=top(s);
s=pop(s);
}
// Se termina la conversion
printf("%.2lf\n",evaluar(posfija, largo));
return 0;
}
/*evaluar toda la poblacion*/
void haz_evaluacion(poblacion *p)
{
int i;
for (i = 0; i < p->tampoblacion; i++) /* evaluar cada cadena*/
{
if (p->es_evaluado[i] == 0) //bandera indica si ya fue evaluado
{
p->aptitud[i] = evaluar(p->bits[i],p->bpi);
p->es_evaluado[i] = 1;
}
}
}
double *vector_aleatorio() {
int j;
double *aux, num;
aux = (double *)malloc(sizeof(double)*10);
while (evaluar(aux) < 1) {
for ( j = 0 ; j < 10 ; j++ ) {
num = (double)(random())/RAND_MAX;
num = num*2 -1;
aux[j] = num;
}
}
return aux;
}
double Neurona::entrenamiento( QVector<double> entradas, double salidaDeseada )
{
double salida = evaluar( entradas );
// Ajusto los pesos
double error = salidaDeseada - salida;
//Caso del w0 y x0. x0 siempre es -1 no importa cuantas epocas haga
_pesos[0] = _pesos.at(0) + _tasa_aprendizaje*error*(-1.0);
for(int i=1 ; i<=entradas.size() ; i++) {
_pesos[i]=_pesos.at(i) + _tasa_aprendizaje*error*entradas.at(i-1);
}
return error;
}
void getParents(double poblacion[1000][10], double parents[2][10]){
int i;
int imadre = 0;
int ipadre = 9;
int itemp;
double evalpadre = -999;
double evalmadre = -999;
double temp;
for(i = 0; i < 1000; i++){
numeval++;
temp = evaluar(poblacion[i]);
if((((temp > evalpadre)) && ((double)rand()/((double)(RAND_MAX)+(double)(1)) < 0.6)) || ((double)rand()/((double)(RAND_MAX)+(double)(1)) < 0.2)){
evalmadre = evalpadre;
imadre = ipadre;
ipadre = i;
evalpadre = temp;
}else if(((temp > evalmadre) && ((double)rand()/((double)(RAND_MAX)+(double)(1)) < 0.6)) || ((double)rand()/((double)(RAND_MAX)+(double)(1)) < 0.2)){
imadre = i;
evalmadre = temp;
}
}
memcpy(parents[0],poblacion[ipadre],sizeof(double)*10);
memcpy(parents[1],poblacion[imadre],sizeof(double)*10);
}
/*!
* \brief main
* Guia de Trabajos Practicos 3
* \param argc
* \param argv
* \return
*/
int main(int argc, char *argv[])
{
QApplication a( argc, argv );
QMainWindow main;
a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
main.showMaximized();
QMdiArea *mdiArea = new QMdiArea;
mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
main.setCentralWidget(mdiArea);
GraficadorMdi *grafFuncion = new GraficadorMdi( mdiArea );
grafFuncion->setearTitulo( QString::fromUtf8( "Funcion" ) );
grafFuncion->setearTituloEjeX( QString::fromUtf8( "X" ) );
grafFuncion->setearTituloEjeY( QString::fromUtf8( "Y" ) );
mdiArea->addSubWindow( grafFuncion );
grafFuncion->show();
mdiArea->tileSubWindows();
GraficadorMdi *grafFitnes = new GraficadorMdi( mdiArea );
grafFitnes->setearTitulo( QString::fromUtf8( "Evolucion Mejor Fitness" ) );
grafFitnes->setearTituloEjeX( QString::fromUtf8( "Generacion" ) );
grafFitnes->setearTituloEjeY( QString::fromUtf8( "fitness" ) );
mdiArea->addSubWindow( grafFitnes );
grafFitnes->show();
mdiArea->tileSubWindows();
grafFitnes->setearParaSOM();
GraficadorMdi *grafPuntos = new GraficadorMdi( mdiArea );
grafPuntos->setearTitulo( QString::fromUtf8( "Puntos a evaluar" ) );
grafPuntos->setearTituloEjeX( QString::fromUtf8( "Posicion" ) );
grafPuntos->setearTituloEjeY( QString::fromUtf8( "Y" ) );
mdiArea->addSubWindow( grafPuntos );
grafPuntos->show();
mdiArea->tileSubWindows();
//grafPuntos->setearParaSOM();
// grafPuntos->setearEjesEnGrafico();
GraficadorMdi *grafPromedio = new GraficadorMdi( mdiArea );
grafPromedio->setearTitulo( QString::fromUtf8( "Fitness Promedio" ) );
grafPromedio->setearTituloEjeX( QString::fromUtf8( "Posicion" ) );
grafPromedio->setearTituloEjeY( QString::fromUtf8( "Y" ) );
mdiArea->addSubWindow( grafPromedio );
grafPromedio->show();
mdiArea->tileSubWindows();
grafPromedio->setearParaSOM();
// barra de progreso para mostrar el avance del tiempo
QDockWidget *dockBarra = new QDockWidget( QString::fromUtf8( "Evaluaciones" ) );
main.addDockWidget( Qt::BottomDockWidgetArea, dockBarra );
QProgressBar *PBTiempo = new QProgressBar( dockBarra );
dockBarra->setWidget( PBTiempo );
//Inicializo con una semilla aleatoria para la generacion de Aleatorios
qsrand( QTime::currentTime().msec() );
// Cargo los parametros del ejercicio
QSettings parametros( "parametros.cfg", QSettings::IniFormat );
// Inicializo la poblacion
Poblacion<GenomaX> pob;
int cant_total = parametros.value( "cantidad_elementos" ).toInt();
pob.setearTotal( cant_total );
pob.setearElitismo( parametros.value( "elitismo", false ).toBool() );
pob.setearBrechaGeneracional( parametros.value( "brecha_generacional" ).toDouble() );
pob.setearProbabilidadMutacion( parametros.value( "probabilidad_mutacion").toDouble() );
pob.setearModoSeleccionPadres( (Poblacion<GenomaX>::MetodoSeleccion)parametros.value( "metodo_seleccion" ).toInt() );
pob.setearPorcentajeCantidadDePadres( parametros.value( "cantidad_padres" ).toDouble() );
double max = parametros.value( "max" ).toDouble();
double min = parametros.value( "min" ).toDouble();
pob.setearMinMax( min, max );
for( int i=0; i<cant_total; i++ ) {
GenomaX temp;
double valor = valor_random( min, max );
temp.setX( valor );
temp.setMinMax( min, max );
pob.append( temp );
}
// Grafico la funcion
QVector<double> posy, posx;
for( double i=min; i<max; i+=0.05 ) {
posx.append( i );
posy.append( evaluar( i ) );
}
grafFuncion->agregarCurva( posx, posy, "funcion" );
a.processEvents();
/*GenomaX p1;
p1.setX( 128.0 );
p1.mostrarGenotipo();
p1.mutar( 9 );
p1.mostrarGenotipo();
p1.mutar( 1 );
p1.mostrarGenotipo();
p1.mutar( 2 );
p1.mostrarGenotipo();
p1.mutar( 15 );
p1.mostrarGenotipo();
p1.mutar( 10 );
p1.mostrarGenotipo();
p1.mutar( 11 );
p1.mostrarGenotipo();*/
double fitnes_necesario = parametros.value( "fitnes_necesario", 0.0 ).toDouble();
int iteracciones_maximas = parametros.value( "iteracciones_maximas", 1000 ).toInt();
int iteracciones = 0;
PBTiempo->setRange( 0, iteracciones_maximas );
pob.evaluarPoblacion();
a.processEvents();
QVector<double> histFitness;
QVector<int> histIteracion;
QVector<double> histPromFitnes;
histFitness.append( pob.mejorFitnes() );
histIteracion.append( 0 );
histPromFitnes.append( pob.mejorFitnes() );
double mejor_fitness = 0.0;
double pos_mejor_fitness = 0.0;
int generacion_mejor_fitness = -1;
while( pob.mejorFitnes() <= fitnes_necesario
&& iteracciones <= iteracciones_maximas ) {
pob.seleccionarPadres();
a.processEvents();
pob.generarHijos();
a.processEvents();
pob.evaluarPoblacion();
a.processEvents();
iteracciones++;
PBTiempo->setValue( iteracciones );
histFitness.append( pob.mejorFitnes() );
histIteracion.append( iteracciones );
grafFitnes->setearPuntos( histFitness, histIteracion );
a.processEvents();
QVector<double> x, y;
double sumatoria = 0.0;
for( int i=0; i<pob.size(); i++ ) {
y.append( i );
x.append( pob.at( i ).getX() );
sumatoria += (-1.0)*evaluar( pob.at( i ).getX() );
}
sumatoria /= pob.size();
histPromFitnes.append( sumatoria );
grafPuntos->agregarCurva( x, y, QString( "Gen%1" ).arg( iteracciones ) );
if( mejor_fitness <= pob.mejorFitnes() ) {
mejor_fitness = pob.mejorFitnes();
pos_mejor_fitness = pob.elementoMinimo().getX();
generacion_mejor_fitness = iteracciones;
}
grafPromedio->setearPuntos( histPromFitnes, histIteracion );
}
qDebug() << "Mejor Fitness: " << mejor_fitness;
qDebug() << "Posicion Minimo: " << pos_mejor_fitness;
qDebug() << "Minimo: " << evaluar( pos_mejor_fitness );
qDebug() << "Generacion: " << generacion_mejor_fitness;
return a.exec();
}
int main() {
int i;
double x[10];
double num, max;
double *sucesor = (double *)malloc(sizeof(double)*10);
struct timeval t;
double t_ini,t_fin,tiempo,seg;
int min;
/**************************** Generacion y evaluacion del punto inicial para Hill y SImulated**************************/
gettimeofday (&t, NULL);
srand(t.tv_sec + t.tv_usec);
for ( i = 0 ; i < 10 ; i++ ) { x[i] = 0; }
for ( i = 0 ; i < 10 ; i++ ) {
num = (double)rand()/((double)(RAND_MAX)+(double)(1));
num = num*2 -1;
x[i] = num;
}
printf("\nUbicacion del Inicial para Hill-Climbing y Simulated-Anneling: ");
for ( i = 0 ; i < 10 ; i++ ) printf("%.10f ",x[i]);
printf("\nEvaluacion Nodo Inicial: %.10lf\n\n",evaluar(x));
/***************************************** Corre Hill-Climbing *******************************************/
gettimeofday (&t, NULL);
t_ini = (double)t.tv_sec + (t.tv_usec/1000000.0);
llamadas = 0;
printf("\nUbicacion del Maximo: ");
max = hill_climbing(x);
printf("\nMaximo - Hill Climbing = %.10lf\n",max);
printf("Numero de llamadas a la funcion objetivo = %d\n",llamadas);
gettimeofday (&t, NULL);
t_fin = (double)t.tv_sec + (t.tv_usec/1000000.0);
tiempo = t_fin - t_ini;
printf("Tiempo de ejecucion Hill-Clibing: %f segundo(s)\n", tiempo);
printf("\n");
/***************************************** Corre Simulated-Anneling *******************************************/
gettimeofday (&t, NULL);
t_ini = (double)t.tv_sec + (t.tv_usec/1000000.0);
llamadas = 0;
printf("Ubicacion del Maximo: ");
max = simulated_anneling(x,8000,40,25);
printf("\nMaximo - Simulated Anneling = %.10lf\n",max);
printf("Numero de llamadas a la funcion objetivo = %d\n",llamadas);
gettimeofday (&t, NULL);
t_fin = (double)t.tv_sec + (t.tv_usec/1000000.0);
tiempo = t_fin - t_ini;
printf("Tiempo de ejecucion Simulated-Anneling: %f segundo(s)\n", tiempo);
printf("\n");
/***************************************** Corre Algoritmo-Genetico *******************************************/
gettimeofday (&t, NULL);
t_ini = (double)t.tv_sec + (t.tv_usec/1000000.0);
llamadas = 0;
printf("\nUbicacion del Maximo: ");
max = genetic_alg();
printf("\nMaximo - Algoritmo Genetico = %.10lf\n",max);
printf("Numero de llamadas a la funcion objetivo = %d\n",llamadas);
gettimeofday (&t, NULL);
t_fin = (double)t.tv_sec + (t.tv_usec/1000000.0);
tiempo = t_fin - t_ini;
printf("Tiempo de ejecucion Alg-Genetico: %f segundo(s)\n", tiempo);
printf("\n");
exit(0);
}
double genetic_alg() {
int i, j, k, count, pos_max;
double max, sum, alfa;
double **poblacion = (double* *)malloc(sizeof(double *)*20);
double **pob_div = (double* *)malloc(sizeof(double *)*20);
double **hijos = (double* *)malloc(sizeof(double *)*10);
double norm[20], norm_aux[20], num, valor_medio;
sum = 0;
poblacion = gen_familia();
count = 0;
while (count < 200) {
//////SELECCION///////
for (i = 0 ; i < 20 ; i++ ) { norm[i] = evaluar(poblacion[i]); }
copiar_vector(20,norm_aux,norm);
//////DIVISON ENTRE MEJORES Y PEORES//////
for (i = 0 ; i < 20 ; i++ ) { norm_aux[i] *= 1000.0; }
qsort(norm_aux,20,sizeof(double),compare);
for (i = 0 ; i < 20 ; i++ ) { norm_aux[i] /= 1000.0; }
valor_medio = norm_aux[10];
j = 0;
k = 19;
for ( i = 0 ; i < 20 ; i++ ) {
if (valor_normal(norm,i) > valor_medio) {
pob_div[j] = poblacion[i];
j++;
}
else {
pob_div[k] = poblacion[i];
k--;
}
}
///////REPRODUCCION//////
hijos = gen_familia_nueva(pob_div);
//////MUTACION///////
mutacion(hijos);
//////REPOBLACION//////
for ( i = 0 ; i < 10 ; i++ ) pob_div[10+i] = hijos[i];
poblacion = pob_div;
count++;
}
/////////SELECCION DEL MAXIMO/////////
max = 0;
for ( i = 0 ; i < 20 ; i++ )
if (max < evaluar(poblacion[i])) {
max = evaluar(poblacion[i]);
pos_max = i;
}
for ( j = 0 ; j < 10 ; j++ ) printf("%.10lf ",poblacion[pos_max][j]);
return max;
}
int comparar_pos(double a[10], double b[10]){
numeval += 2;
return (double) (evaluar(b) - evaluar(a));
}
