Exemple #1
0
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);
}
Exemple #2
0
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;
}
Exemple #3
0
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;	
	}
}
Exemple #5
0
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);

}
Exemple #6
0
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);
		}
	}
}
Exemple #8
0
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;
		}
	}
}
Exemple #11
0
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;

}
Exemple #13
0
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();
}
Exemple #15
0
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);

}
Exemple #16
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;
}
Exemple #17
0
int comparar_pos(double a[10], double b[10]){
  numeval += 2;
  return (double) (evaluar(b) - evaluar(a));
}