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)); }