Esempio n. 1
0
int main()
{
 char gene[POOLSIZE][RULESIZE][LOCUSSIZE] ;//遺伝子プール
 char midgene[POOLSIZE*2][RULESIZE][LOCUSSIZE] ;//増殖中の遺伝子プール
 char lines[MAXLINES][LINESIZE] ;//キーワードのデータ
 int lineno ;//キーワードデータの行数
 int generation ;
 srand(65535) ;//乱数の初期化
 lineno=readlines(lines) ;//キーワードデータの読み込み
 initgene(gene) ;//遺伝子プールの初期化
 for(generation=0;generation<GMAX;++generation){
  printf("第%d世代 平均適応度 %f\n",generation,fave(gene,lines,lineno)) ;
  printgene(gene,lines,lineno) ;//遺伝子プールの出力
  crossover(midgene,gene,lines,lineno) ;//交叉
  mutation(midgene) ;//突然変異
  selection(gene,midgene,lines,lineno) ;//選択
 }
  printf("第%d世代 平均適応度 %f\n",generation,fave(gene,lines,lineno)) ;
  printgene(gene,lines,lineno) ;//遺伝子プールの出力

 return 0 ;
}
Esempio n. 2
0
Population run_island(Configuration conf, Individual initial_individual){
    // Random Number Generation
    std::default_random_engine eng(std::random_device{}());
    std::uniform_real_distribution<> dist(-5, 5);
    
    // population generation
    Population population;
    population.push_back(initial_individual);    // push the initial as it is.
    for (int i=1; i<conf.pop_size; i++) {
        Individual indi = mutate(conf, initial_individual);
        population.push_back(indi);
    }
    
    int generations = conf.num_generations;
    for (int g=0; g<generations; g++) {
        // first fitness calculation
        for (int i=0; i<conf.pop_size; i++) {
            population[i].score = fitness(population[i]);
        }
        
        // do sorting according to score
        std::sort(population.begin(), population.end(), compare);
        
        if (g != (conf.num_generations - 1)) {
            // crossover
            for (int i=0; i<(conf.pop_size / 2); i++) {
                crossover(conf, population[2*i], population[2*i+1]);
            }
            
            // mutate
            for (int i=0; i<conf.pop_size; i++) {
                population[i] = mutate(conf, population[i]);
            }
        }
    }
    
    return population;
}
Esempio n. 3
0
void GA::step()
{
  pop_vector children;
  children.clear();
  children.reserve(m_population_size);

  // elitism
  unsigned int elite_size = m_population_size * m_elitism_rate;

  for (unsigned int i=0; i<elite_size; i++) {
    children.push_back(m_population[i]->copy());
  }

  // crossover
  while (children.size() < (m_population_size - elite_size)) {

    // select parents
    int p1 = roulette();
    int p2 = roulette();

    // crossover parents
    crossover(m_population[p1], m_population[p2], children);
  }

  // mutation
  mutate(children);

  // update population and save last population
  update(children);

  // evaluate fitness and sort
  evaluate_fitness();

  // log, save generation
  log();

  save_histograms();
}
static void reproduce_next_generation(
    network_config *config,
    individual_t** individuals,
    int size,
    int weight_cout,
    double rate){
 int pos = size;
 int i, j, k;
 #pragma omp parallel for shared(config, pos,individuals,size,weight_cout,rate) private(i,j,k)
 for (i = 0; i < size; ++i) {
  for (j = i + 1; j < size; ++j) {
   for (k = 0; k < weight_cout; ++k) {
    double w1 = individuals[i]->weights[k];
    double w2 = individuals[j]->weights[k];
    crossover(config, w1,w2,individuals[pos]->weights+k,individuals[pos+1]->weights+k);
    mutation(config, individuals[pos]->weights+k,rate);
    mutation(config, individuals[pos+1]->weights+k,rate);
   }
   #pragma omp atomic
   pos+=2;
  }
 }
}
Esempio n. 5
0
void SolverEvolver::evolve()
{
	sort_by_fitness();

	std::vector<Individual> child_population;
	while (child_population.size() < population_size_)
	{
		Individual& c0 = select();
		Individual& c1 = select();

		if (rand_.NextBool(combination_p_))
		{
			crossover(c0.genome, c1.genome);
		}
		mutate(c0.genome);
		mutate(c1.genome);

		child_population.push_back(c0);
		child_population.push_back(c1);
	}
	population_ = child_population;
	initate_population();
}
Esempio n. 6
0
void main()
{
	int i;
	int isUnique;
	Individual best;

	randomize();

	worldInit();

	// max 4 unique individuals, 5 and more last long to find
	while(uniques < 4){
		populationInit();
		fitness();

		for(i = 0; i < maxGenerations; i++){

			selection();
			crossover();
			mutation();
			fitness();

			best = getBestIndividual();

			if(best.fitness == maxFitness){
				isUnique = unique(best);
				if(isUnique){
					theBestOf[uniques] = best;
					uniques++;
				}
				break;
			}
		}
	}

	printAxisOfBest();
}
Esempio n. 7
0
std::vector<Genome> GenAlg::new_generation(std::vector<Genome> &last_generation)
{
	generation_count++;
	
	reset();
	
	std::sort(last_generation.begin(), last_generation.end(), myComparer);
	
	calculateStatistics();
	
	std::vector<Genome> new_population;
	
	//get elites
	GetBest(my_params.num_elite, my_params.num_copies_of_elite, last_generation, new_population);
	
	//genetic algorithm loop
	while(new_population.size() < pop_size)
	{
		Genome mother = getRandomChromosome();
		Genome father = getRandomChromosome();
		
		std::vector<float> child1, child2;
		
		crossover(mother.weights, father.weights, child1, child2);
		
		mutate(child1);
		mutate(child2);
		
		new_population.push_back(Genome(child1, 0));
		new_population.push_back(Genome(child2, 0));
	}
	
	population = new_population;
	
	return population;
}
Esempio n. 8
0
int GAConjProblemForORGroupSolver::reproduction( )
{
  int pr = ( theIter2<2*numGenes ? 0 : 1 );
  switch( roulette( 3 , prob[pr] ) ) {
  case 0: 
    {
      int g = selectGene( );
      *newGene[0] = *genes[g];
      if( newGene[0]->mutation( ) ) return 1;
    }
    break;
  case 1:
    {
      int g = selectGene( );
      *newGene[0] = *genes[g];
      if( newGene[0]->permutation( ) ) return 1;
    }
    break;
  case 2:
    {
      int g1 = selectGene( );
      int g2;
      {
	GACPforORGSolverGene *_tmp = genes[g1];
	genes[g1] = 0;
	g2 = selectGene( );
	genes[g1] = _tmp;
      }
      *newGene[0] = *genes[g1];
      *newGene[1] = *genes[g2];
      if( crossover( *newGene[0] , *newGene[1] ) ) return 2;
    }
    break;
  }
  return 0;
}
int main(int argc, char *argv[])
{
	/*define local variables*/
	clock_t start, end, t1, t2, t3, t4;
	int i,g; //counters
	    //maxrank1; //the larger maxrank between oldpop and matepop
	//double tot; //sum of no. of inds in a rank in both oldpop and newpop
	FILE *rep_ptr, *lastit;/*File Pointers*/
	
    if( argc == 2 )
		printf("The argument supplied is %s\n", argv[1]);
	else if( argc > 2 )
		printf("Too many arguments supplied.\n");
	else
		printf("One argument expected.\n");		
	seed = (double)atof(argv[1]);
	if (seed<=0.0 || seed>=1.0)
    {
        printf("\n Entered seed value is wrong, seed value must be in (0,1) \n");
        exit(11);
    }
  /*open files*/
	rep_ptr=fopen ("output.out","w");
	lastit = fopen("plot.out","w");
	
	old_pop_ptr=&(oldpop);
	
	no_mut1=0;
	no_mut2=0;
	no_cross = 0;
	
	input(rep_ptr);  /*obtain inputs*/
	randomize(); /*initialize random no. generator*/
	
  /*initialize population*/
	init(old_pop_ptr);
	//debug
	/*printf("\n The initial population are:");
	printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
	for (i=0;i<popsize;i++) {
		printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
	}*/

  /*decode integer chromosomes*/
	if (no_intevar>0) {
		decode(old_pop_ptr);
	}
	//debug
	/*printf("\n The decoded initial population are:");
	printf("\n DV1 DV2   D_DV1x   D_DV1y   D_DV1z   D_DV1u   D_DV1v   D_DV1x   D_DV1y   D_DV1z   D_DV1u   D_DV1v");
	for (i=0;i<popsize;i++) {
		printf("\n %d   %d  %.4f    %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f ",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].xchrom1[0],old_pop_ptr->ind[i].ychrom1[0],
			old_pop_ptr->ind[i].zchrom1[0],old_pop_ptr->ind[i].uchrom1[0],
			old_pop_ptr->ind[i].vchrom1[0],old_pop_ptr->ind[i].xchrom1[1],
			old_pop_ptr->ind[i].ychrom1[1],old_pop_ptr->ind[i].zchrom1[1],
			old_pop_ptr->ind[i].uchrom1[1],old_pop_ptr->ind[i].vchrom1[1]);
	}*/
  
  /*initialize the rank array having different individuals at
  a particular rank to zero*/
	new_pop_ptr=&(newpop);
	for (i=0;i<popsize;i++) {
		old_pop_ptr->rankno[i]=0;
		new_pop_ptr->rankno[i]=0;
		old_pop_ptr->ind[i].tag=1;
	}
  
  /*evaluation the objective and constraint functions of the current population*/
	noeval=0;
	//assig generation number to each ind in matepop
	evaluatepop(old_pop_ptr, -1);
	for (i=0;i<popsize;i++) {
		old_pop_ptr->ind[i].tag=0;
	}
	//debug
	/*printf("\n After evaluation the initial oldpop are:");
	printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
	for (i=0;i<popsize;i++) {
		printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
	}*/
	//rank the oldpop before copy it into midpop and selection
	if (no_cons==0) {
		old_pop_ptr->ind_ptr->overallcons=0.0;
		ranking(old_pop_ptr);
	}
	else {
		rankcon(old_pop_ptr);
	}
	//debug
	/*printf("\n After ranking/rankcon the initial oldpop are:");
	printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
	for (i=0;i<popsize;i++) {
		printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
	}*/
	
	
  /***********************************************************************************/
  /****************************GNENRATION LOOP STARTS*********************************/
	
	for (g=0;g<no_gener;g++) {
		printf("\nGeneration number = %d\n", g+1);
		start=clock();
		//fprintf(rep_ptr,"Population at Generation No. -->%d\n",g+1);
		//fprintf(rep_ptr,"#Generation No. -->%d\n",g+1);
		//fprintf(rep_ptr,"#Variable_vector  Fitness_vector  Constraint_violation  Overall_violation\n");
		
		old_pop_ptr=&(oldpop);
		mid_pop_ptr=&(midpop);
		mate_pop_ptr=&(matepop);
		new_pop_ptr=&(newpop);
		best_pop_ptr=&(bestpop);
		
	 /**********************Two-member Tournament Selection***************************/
		//copy oldpop into midpop-midpop is the exact copy of oldpop
		copypop(old_pop_ptr, mid_pop_ptr);
		
		//debug
		/*printf("\n ===================Copypop==========================\n");
		printf("\n In generation loop:After copypop the initial oldpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After copypop the midpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mid_pop_ptr->ind[i].chrom1[0],mid_pop_ptr->ind[i].chrom1[1],
			mid_pop_ptr->ind[i].chrom2[0],mid_pop_ptr->ind[i].chrom2[1],
			mid_pop_ptr->ind[i].fit[0],mid_pop_ptr->ind[i].fit[1],
			mid_pop_ptr->ind[i].cons[0],mid_pop_ptr->ind[i].cons[1],
			mid_pop_ptr->ind[i].overallcons,mid_pop_ptr->ind[i].cub_len,
			mid_pop_ptr->ind[i].rank,mid_pop_ptr->ind[i].tag,
			mid_pop_ptr->ind[i].eval,mid_pop_ptr->ind[i].gen);
		}*/
		
		//shuffle midpop and select from oldpop+midpop to form matepop
		selectt(old_pop_ptr, mid_pop_ptr, mate_pop_ptr);
		
		//debug
		/*printf("\n===================Select===========================\n");
		printf("\n In generation loop:After selection the initial oldpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After selection the midpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mid_pop_ptr->ind[i].chrom1[0],mid_pop_ptr->ind[i].chrom1[1],
			mid_pop_ptr->ind[i].chrom2[0],mid_pop_ptr->ind[i].chrom2[1],
			mid_pop_ptr->ind[i].fit[0],mid_pop_ptr->ind[i].fit[1],
			mid_pop_ptr->ind[i].cons[0],mid_pop_ptr->ind[i].cons[1],
			mid_pop_ptr->ind[i].overallcons,mid_pop_ptr->ind[i].cub_len,
			mid_pop_ptr->ind[i].rank,mid_pop_ptr->ind[i].tag,
			mid_pop_ptr->ind[i].eval,mid_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After selection the matepop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mate_pop_ptr->ind[i].chrom1[0],mate_pop_ptr->ind[i].chrom1[1],
			mate_pop_ptr->ind[i].chrom2[0],mate_pop_ptr->ind[i].chrom2[1],
			mate_pop_ptr->ind[i].fit[0],mate_pop_ptr->ind[i].fit[1],
			mate_pop_ptr->ind[i].cons[0],mate_pop_ptr->ind[i].cons[1],
			mate_pop_ptr->ind[i].overallcons,mate_pop_ptr->ind[i].cub_len,
			mate_pop_ptr->ind[i].rank,mate_pop_ptr->ind[i].tag,
			mate_pop_ptr->ind[i].eval,mate_pop_ptr->ind[i].gen);
		}*/
	  
	 /***********************************Crossover************************************/
	 //one-point crossover for chrom1 and SBX for chrom2
	 //before crossover and mutation set tag to zero
		for (i=0;i<popsize;i++) {
			new_pop_ptr->ind[i].tag=0;
		}
		crossover(new_pop_ptr, mate_pop_ptr);
		
		//debug
		/*printf("\n===================Crossover===========================\n");
		printf("\n In generation loop:After crossover matepop, the initial oldpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After crossover matepop, the midpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mid_pop_ptr->ind[i].chrom1[0],mid_pop_ptr->ind[i].chrom1[1],
			mid_pop_ptr->ind[i].chrom2[0],mid_pop_ptr->ind[i].chrom2[1],
			mid_pop_ptr->ind[i].fit[0],mid_pop_ptr->ind[i].fit[1],
			mid_pop_ptr->ind[i].cons[0],mid_pop_ptr->ind[i].cons[1],
			mid_pop_ptr->ind[i].overallcons,mid_pop_ptr->ind[i].cub_len,
			mid_pop_ptr->ind[i].rank,mid_pop_ptr->ind[i].tag,
			mid_pop_ptr->ind[i].eval,mid_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After crossover matepop, the matepop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mate_pop_ptr->ind[i].chrom1[0],mate_pop_ptr->ind[i].chrom1[1],
			mate_pop_ptr->ind[i].chrom2[0],mate_pop_ptr->ind[i].chrom2[1],
			mate_pop_ptr->ind[i].fit[0],mate_pop_ptr->ind[i].fit[1],
			mate_pop_ptr->ind[i].cons[0],mate_pop_ptr->ind[i].cons[1],
			mate_pop_ptr->ind[i].overallcons,mate_pop_ptr->ind[i].cub_len,
			mate_pop_ptr->ind[i].rank,mate_pop_ptr->ind[i].tag,
			mate_pop_ptr->ind[i].eval,mate_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After crossover matepop, the newpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].chrom2[0],new_pop_ptr->ind[i].chrom2[1],
			new_pop_ptr->ind[i].fit[0],new_pop_ptr->ind[i].fit[1],
			new_pop_ptr->ind[i].cons[0],new_pop_ptr->ind[i].cons[1],
			new_pop_ptr->ind[i].overallcons,new_pop_ptr->ind[i].cub_len,
			new_pop_ptr->ind[i].rank,new_pop_ptr->ind[i].tag,
			new_pop_ptr->ind[i].eval,new_pop_ptr->ind[i].gen);
		}*/
		
	 /***********************************Mutation************************************/
	 //adjacent mutation for chrom1 and polynomial mutation for chrom2
		//debug to check if tag assigning is working in mutation.c
		/*for(i=0;i<popsize;i++) {
			new_pop_ptr->ind[i].tag=0;
		}*/
		mutation(new_pop_ptr);
		
		//debug
		/*printf("\n===================Mutation===========================\n");
		printf("\n In generation loop:After mutating newpop, the initial oldpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After mutating newpop, the midpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mid_pop_ptr->ind[i].chrom1[0],mid_pop_ptr->ind[i].chrom1[1],
			mid_pop_ptr->ind[i].chrom2[0],mid_pop_ptr->ind[i].chrom2[1],
			mid_pop_ptr->ind[i].fit[0],mid_pop_ptr->ind[i].fit[1],
			mid_pop_ptr->ind[i].cons[0],mid_pop_ptr->ind[i].cons[1],
			mid_pop_ptr->ind[i].overallcons,mid_pop_ptr->ind[i].cub_len,
			mid_pop_ptr->ind[i].rank,mid_pop_ptr->ind[i].tag,
			mid_pop_ptr->ind[i].eval,mid_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After mutating newpop, the matepop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mate_pop_ptr->ind[i].chrom1[0],mate_pop_ptr->ind[i].chrom1[1],
			mate_pop_ptr->ind[i].chrom2[0],mate_pop_ptr->ind[i].chrom2[1],
			mate_pop_ptr->ind[i].fit[0],mate_pop_ptr->ind[i].fit[1],
			mate_pop_ptr->ind[i].cons[0],mate_pop_ptr->ind[i].cons[1],
			mate_pop_ptr->ind[i].overallcons,mate_pop_ptr->ind[i].cub_len,
			mate_pop_ptr->ind[i].rank,mate_pop_ptr->ind[i].tag,
			mate_pop_ptr->ind[i].eval,mate_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After mutating newpop, the newpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].chrom2[0],new_pop_ptr->ind[i].chrom2[1],
			new_pop_ptr->ind[i].fit[0],new_pop_ptr->ind[i].fit[1],
			new_pop_ptr->ind[i].cons[0],new_pop_ptr->ind[i].cons[1],
			new_pop_ptr->ind[i].overallcons,new_pop_ptr->ind[i].cub_len,
			new_pop_ptr->ind[i].rank,new_pop_ptr->ind[i].tag,
			new_pop_ptr->ind[i].eval,new_pop_ptr->ind[i].gen);
		}*/
		
		
	 /*************Decode the integer chromosome of the child population*************/ 
		if (no_intevar>0) 
			decode(new_pop_ptr);
		//debug
		/*printf("\n The decoded newpop after mutation are:");
		printf("\n DV1 DV2   D_DV1x   D_DV1y   D_DV1z   D_DV1u   D_DV1v   D_DV1x   D_DV1y   D_DV1z   D_DV1u   D_DV1v");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f    %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f ",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].xchrom1[0],new_pop_ptr->ind[i].ychrom1[0],
			new_pop_ptr->ind[i].zchrom1[0],new_pop_ptr->ind[i].uchrom1[0],
			new_pop_ptr->ind[i].vchrom1[0],new_pop_ptr->ind[i].xchrom1[1],
			new_pop_ptr->ind[i].ychrom1[1],new_pop_ptr->ind[i].zchrom1[1],
			new_pop_ptr->ind[i].uchrom1[1],new_pop_ptr->ind[i].vchrom1[1]);
		}
		printf("\n In generation loop:After decoding mutated newpop, the newpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].chrom2[0],new_pop_ptr->ind[i].chrom2[1],
			new_pop_ptr->ind[i].fit[0],new_pop_ptr->ind[i].fit[1],
			new_pop_ptr->ind[i].cons[0],new_pop_ptr->ind[i].cons[1],
			new_pop_ptr->ind[i].overallcons,new_pop_ptr->ind[i].cub_len,
			new_pop_ptr->ind[i].rank,new_pop_ptr->ind[i].tag,
			new_pop_ptr->ind[i].eval,new_pop_ptr->ind[i].gen);
		}*/
		
	 /*Evaluation the objective and constraint functions of the child population*/
		t1=clock();
		evaluatepop(new_pop_ptr, g);
		t2=clock();
		//debug
		/*printf("\n================Evaluatepop in generation loop=================\n");
		printf("\n In generation loop:After evaluatepop  newpop, the newpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].chrom2[0],new_pop_ptr->ind[i].chrom2[1],
			new_pop_ptr->ind[i].fit[0],new_pop_ptr->ind[i].fit[1],
			new_pop_ptr->ind[i].cons[0],new_pop_ptr->ind[i].cons[1],
			new_pop_ptr->ind[i].overallcons,new_pop_ptr->ind[i].cub_len,
			new_pop_ptr->ind[i].rank,new_pop_ptr->ind[i].tag,
			new_pop_ptr->ind[i].eval,new_pop_ptr->ind[i].gen);
		}*/
		
		/*if (no_cons==0) {
			new_pop_ptr->ind_ptr->overallcons=0.0;
			ranking(new_pop_ptr);
		}
		else {
			rankcon(new_pop_ptr);
		}
		printf("\n In generation loop:After ranking/rankcon newpop, the newpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].chrom2[0],new_pop_ptr->ind[i].chrom2[1],
			new_pop_ptr->ind[i].fit[0],new_pop_ptr->ind[i].fit[1],
			new_pop_ptr->ind[i].cons[0],new_pop_ptr->ind[i].cons[1],
			new_pop_ptr->ind[i].overallcons,new_pop_ptr->ind[i].cub_len,
			new_pop_ptr->ind[i].rank,new_pop_ptr->ind[i].tag,
			new_pop_ptr->ind[i].eval,new_pop_ptr->ind[i].gen);
		}*/
	  
	 /************************Selection keeping fronts alive************************/
		 //Elitism and sharing implementation
		t3=clock();
		keepalive(old_pop_ptr, new_pop_ptr, mate_pop_ptr, g+1);
		t4=clock();
		//debug
		/*printf("\n\n=====================Keepalive==========================\n");
		printf("\n In generation loop:After keepalive, the initial oldpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			old_pop_ptr->ind[i].chrom1[0],old_pop_ptr->ind[i].chrom1[1],
			old_pop_ptr->ind[i].chrom2[0],old_pop_ptr->ind[i].chrom2[1],
			old_pop_ptr->ind[i].fit[0],old_pop_ptr->ind[i].fit[1],
			old_pop_ptr->ind[i].cons[0],old_pop_ptr->ind[i].cons[1],
			old_pop_ptr->ind[i].overallcons,old_pop_ptr->ind[i].cub_len,
			old_pop_ptr->ind[i].rank,old_pop_ptr->ind[i].tag,
			old_pop_ptr->ind[i].eval,old_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After keepalive, the newpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			new_pop_ptr->ind[i].chrom1[0],new_pop_ptr->ind[i].chrom1[1],
			new_pop_ptr->ind[i].chrom2[0],new_pop_ptr->ind[i].chrom2[1],
			new_pop_ptr->ind[i].fit[0],new_pop_ptr->ind[i].fit[1],
			new_pop_ptr->ind[i].cons[0],new_pop_ptr->ind[i].cons[1],
			new_pop_ptr->ind[i].overallcons,new_pop_ptr->ind[i].cub_len,
			new_pop_ptr->ind[i].rank,new_pop_ptr->ind[i].tag,
			new_pop_ptr->ind[i].eval,new_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After keepalive, the newly formed matepop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mate_pop_ptr->ind[i].chrom1[0],mate_pop_ptr->ind[i].chrom1[1],
			mate_pop_ptr->ind[i].chrom2[0],mate_pop_ptr->ind[i].chrom2[1],
			mate_pop_ptr->ind[i].fit[0],mate_pop_ptr->ind[i].fit[1],
			mate_pop_ptr->ind[i].cons[0],mate_pop_ptr->ind[i].cons[1],
			mate_pop_ptr->ind[i].overallcons,mate_pop_ptr->ind[i].cub_len,
			mate_pop_ptr->ind[i].rank,mate_pop_ptr->ind[i].tag,
			mate_pop_ptr->ind[i].eval,mate_pop_ptr->ind[i].gen);
		}*/
		
		/*if (no_intevar>0)
			decode(mate_pop_ptr);*/
		//debug
		/*printf("\n The decoded matepop after keepalive are:");
		printf("\n DV1 DV2   D_DV1x   D_DV1y   D_DV1z   D_DV1u   D_DV1v   D_DV1x   D_DV1y   D_DV1z   D_DV1u   D_DV1v");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f    %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.4f ",
			mate_pop_ptr->ind[i].chrom1[0],mate_pop_ptr->ind[i].chrom1[1],
			mate_pop_ptr->ind[i].xchrom1[0],mate_pop_ptr->ind[i].ychrom1[0],
			mate_pop_ptr->ind[i].zchrom1[0],mate_pop_ptr->ind[i].uchrom1[0],
			mate_pop_ptr->ind[i].vchrom1[0],mate_pop_ptr->ind[i].xchrom1[1],
			mate_pop_ptr->ind[i].ychrom1[1],mate_pop_ptr->ind[i].zchrom1[1],
			mate_pop_ptr->ind[i].uchrom1[1],mate_pop_ptr->ind[i].vchrom1[1]);
		}*/
		
	 /*********************************Report printing*****************************/
		
		//debug
		/*printf("\n In generation loop:Before selectbest, the old bestpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			best_pop_ptr->ind[i].chrom1[0],best_pop_ptr->ind[i].chrom1[1],
			best_pop_ptr->ind[i].chrom2[0],best_pop_ptr->ind[i].chrom2[1],
			best_pop_ptr->ind[i].fit[0],best_pop_ptr->ind[i].fit[1],
			best_pop_ptr->ind[i].cons[0],best_pop_ptr->ind[i].cons[1],
			best_pop_ptr->ind[i].overallcons,best_pop_ptr->ind[i].cub_len,
			best_pop_ptr->ind[i].rank,best_pop_ptr->ind[i].tag,
			best_pop_ptr->ind[i].eval,best_pop_ptr->ind[i].gen);
		}*/
		//select best pop
		if (g==0) { //for the first generation form the first bestpop from matepop
			copypop(mate_pop_ptr, best_pop_ptr);
		}
		else {
			selectbest(mate_pop_ptr, best_pop_ptr, g);
		}
		//debug
		/*printf("\n In generation loop:After selectbest, the matepop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			mate_pop_ptr->ind[i].chrom1[0],mate_pop_ptr->ind[i].chrom1[1],
			mate_pop_ptr->ind[i].chrom2[0],mate_pop_ptr->ind[i].chrom2[1],
			mate_pop_ptr->ind[i].fit[0],mate_pop_ptr->ind[i].fit[1],
			mate_pop_ptr->ind[i].cons[0],mate_pop_ptr->ind[i].cons[1],
			mate_pop_ptr->ind[i].overallcons,mate_pop_ptr->ind[i].cub_len,
			mate_pop_ptr->ind[i].rank,mate_pop_ptr->ind[i].tag,
			mate_pop_ptr->ind[i].eval,mate_pop_ptr->ind[i].gen);
		}
		printf("\n In generation loop:After selectbest, the bestpop are:");
		printf("\n DV1 DV2   RDV1   RDV2   fit1   fit2   cons1  cons2  Ocons  cub_len  rank tag eval gen");
		for (i=0;i<popsize;i++) {
			printf("\n %d   %d  %.4f     %.4f   %.4f   %.4f   %.4f   %.4f   %.4f   %.2e     %d   %d  %d   %d",
			best_pop_ptr->ind[i].chrom1[0],best_pop_ptr->ind[i].chrom1[1],
			best_pop_ptr->ind[i].chrom2[0],best_pop_ptr->ind[i].chrom2[1],
			best_pop_ptr->ind[i].fit[0],best_pop_ptr->ind[i].fit[1],
			best_pop_ptr->ind[i].cons[0],best_pop_ptr->ind[i].cons[1],
			best_pop_ptr->ind[i].overallcons,best_pop_ptr->ind[i].cub_len,
			best_pop_ptr->ind[i].rank,best_pop_ptr->ind[i].tag,
			best_pop_ptr->ind[i].eval,best_pop_ptr->ind[i].gen);
		}*/
		
		mogareport(g, best_pop_ptr, mate_pop_ptr, lastit);
		//                                 output.out,
	 /***************************Copy the newpop to oldpop**************************/
	 /***Assign oldpop the value of matepop(cross, mutate, keepalive_selection, 
		so the original oldpop is updated***/
		copypop(mate_pop_ptr, old_pop_ptr);
		for (i=0;i<popsize;i++) {
			old_pop_ptr->ind[i].tag=0;
		}
	  
	 /***************Print the fitness record for the last generation***************/
	   /* if (g==no_gener-1) { //for the last generation
			old_pop_ptr=&(matepop);
			for (f=0;f<popsize;f++) { //printing loop
				old_pop_ptr->ind_ptr=&(old_pop_ptr->ind[f]);
			    //for all feasible and non-dominating solutions
				if ((old_pop_ptr->ind_ptr->overallcons<=0.0) && 
					(old_pop_ptr->ind_ptr->rank==1)) { //if solution is feasible
					for (l=0;l<no_obj;l++) //for each objective
						fprintf(end_ptr, "%f\t", old_pop_ptr->ind_ptr->fit[l]);
					for (l=0;l<no_cons;l++) //for each constraint
						fprintf(end_ptr, "%f\t", old_pop_ptr->ind_ptr->cons[l]);
					if (no_cons>0)
						fprintf(end_ptr, "%f\t", old_pop_ptr->ind_ptr->overallcons);
					fprintf(end_ptr, "\n");
					if (no_realvar>0) { //for real variables
						for (l=0;l<no_realvar;l++)
							fprintf(g_var, "%f\t", old_pop_ptr->ind_ptr->chrom2[l]);
						fprintf(g_var, " ");
					} //loop over realvar ends
					if (no_intevar>0) { //for integer variables
						for (l=0;l<no_intevar;l++)
							fprintf(g_var, "%d\t", old_pop_ptr->ind_ptr->chrom1[l]);
					} //loop over integer var ends
					fprintf(g_var,"\n");
				} //feasibility check ends
			} //loop over f ends (printing)
	    } //end of the last generation */
		end=clock();
		//printf("\n The time to do evaluatepop of this generation is %f seconds", ((double) t2-t1)/CLOCKS_PER_SEC);
		//printf("\n The time to doNS of this generation is %f seconds", ((double) t4-t3)/CLOCKS_PER_SEC);
		//printf("\n The time to do this generation is %f seconds", ((double) end-start)/CLOCKS_PER_SEC);
		//system(" rm -f en* ");
		printf("\n The %d th Generation has finished. ", g+1);
    } /*end of the ith generation*/
  
  /****************************GNENRATION LOOP FINISHES*********************************/
  /*************************************************************************************/
  fprintf(rep_ptr, "No. OF CROSSOVER = %d\n", no_cross);
  fprintf(rep_ptr, "NO. OF MUTATION FOR INTEGER CHROMOSOME= %d\n", no_mut1);
  fprintf(rep_ptr, "NO. OF MUTATION FOR REAL-CODED CHROMOSOME= %d\n", no_mut2);
  fprintf(rep_ptr,
  "-----------------------------------------------------------------------\n");
  fprintf(rep_ptr,
  "----------------Now you can look in the ourput files-------------------\n");
  
  //close files
  fclose(rep_ptr);
  fclose(lastit);
  return(0);
}
Esempio n. 10
0
//run the genetic algorithm initialized before with some training parameters:
//training location, training algorithm, desired error, max_epochs, epochs_between_reports
//see "FeedForwardNNTrainer" class for more details
//printtype specifies how much verbose will be the execution (PRINT_ALL,PRINT_MIN,PRINT_OFF)
void GAFeedForwardNN::evolve(const int n, const float * params, const int printtype){

	if(n<5){printf("TOO FEW PARAMETERS FOR TRAINING\n");exit(1);}
	int layers[nhidlayers+2];
	int functs[nhidlayers+2];
	float learningRate;

	float fitnesses[popsize];
	float totfitness=0;
	float bestFitnessEver=0;
	FloatChromosome newpop[popsize];

	layers[0]=trainingSet->getNumOfInputsPerInstance();
	layers[nhidlayers+1]=trainingSet->getNumOfOutputsPerInstance();

	//for each generation
	for(int gen=0;gen<generations;gen++){
		float bestFitnessGeneration=0;
		int bestFitGenIndex=0;
		totfitness=0;

		printf("GENERATION NUMBER:\t%d\n\n",gen);

		//fitness evaluation of each individual
		for(int i=0;i<popsize;i++){

			printf("\nINDIVIDUAL N:\t%d\n",i);

			//decode the chromosome hidden layers sizes
			for(int j=0;j<nhidlayers;j++){
				layers[j+1]=chromosomes[i].getElement(j);
			}
			//decode the chromosome activation functions for each layer
			for(int j=0;j<nhidlayers+2;j++){
				functs[j]=chromosomes[i].getElement(j+nhidlayers);
			}
			//decode the chromosome learning rate
			learningRate=chromosomes[i].getElement(nhidlayers+nhidlayers+2);

			float medium=0;

			FeedForwardNN mseT;

			//do a number of evaluations with different weights and average the results
			for(int n=0;n<numberofevaluations;n++){

				//choose what to print based on user's choice
				int print=PRINT_ALL;
				if(printtype==PRINT_MIN){
					if(n==0)
						print=PRINT_MIN;
					else
						print=PRINT_OFF;
				}
				if(printtype==PRINT_OFF)
					print=PRINT_OFF;

				//decode the chromosome into a real network
				FeedForwardNN net(nhidlayers+2,layers,functs);

				FeedForwardNNTrainer trainer;
				trainer.selectTrainingSet(*trainingSet);
				if(testSet!=NULL){
					trainer.selectTestSet(*testSet);
				}
				trainer.selectNet(net);

				trainer.selectBestMSETestNet(mseT);

				float par[]={params[0],params[1],params[2],params[3],params[4],learningRate,0,SHUFFLE_ON,ERROR_LINEAR};

				//do the training of the net and evaluate is MSE error
				medium+=trainer.train(9,par,print)/float(numberofevaluations);
			}

			//the fitness is computed as the inverse of the MSE
			fitnesses[i]=1.0f/medium;

			printf("FITNESS:\t%.2f\n\n",fitnesses[i]);

			//updates the best individual of the generation
			if(fitnesses[i]>bestFitnessGeneration){bestFitnessGeneration=fitnesses[i];bestFitGenIndex=i;}

			//if this is the best fitness ever it store the network in bestNet
			if(bestNet!=NULL)
			if(fitnesses[i]>bestFitnessEver){*bestNet=mseT;bestFitnessEver=fitnesses[i];}

			totfitness+=fitnesses[i];
		}

		//the best individual is always carried to the next generation
		newpop[0]=chromosomes[bestFitGenIndex];

		//generate the new population
		for(int i=1;i<popsize;i++){
			//selection
			int firstmate=0,secondmate=0;

			//first mate
			switch(selectionalgorithm){
				case ROULETTE_WHEEL:		firstmate=rouletteWheel(popsize,fitnesses);					break;
				case TOURNAMENT_SELECTION:	firstmate=tournament(popsize,fitnesses,popsize/5+1);		break;
				default:					printf("SELECTION ALGORITHM NOT IMPLEMENTED YET\n");exit(1);break;
			}
			//second mate
			do{
				switch(selectionalgorithm){
					case ROULETTE_WHEEL:		secondmate=rouletteWheel(popsize,fitnesses);				break;
					case TOURNAMENT_SELECTION:	secondmate=tournament(popsize,fitnesses,popsize/5+1);		break;
					default:					printf("SELECTION ALGORITHM NOT IMPLEMENTED YET\n");exit(1);break;
				}
			}while(firstmate==secondmate);


			FloatChromosome child;
			//do the crossover
			child=crossover(chromosomes[firstmate],chromosomes[secondmate],pcross);
			//and the mutation
			child=mutation(child,pmut,maxdimhiddenlayers,nhidlayers);
			//and put the child in the new generation
			newpop[i]=child;
		}

		//copy the new generation over the older one, wich is the one we will still use
		for(int i=0;i<popsize;i++){
			chromosomes[i]=newpop[i];
		}
	}

}
Esempio n. 11
0
File: sup2.c Progetto: daydin/maze
void createNewPopulation(void)
{
  //double newpop[POP_SIZE][NB_GENES];
  _Bool newpop_bin[POP_SIZE][GENOME_LENGTH];


  int elitism_counter = round(POP_SIZE*ELITISM_RATIO);
  double total_fitness = 0;
  // find minimum fitness to subtract it from sum
  double min_fitness = sortedfitness[POP_SIZE-1][0];
  if (min_fitness<0) min_fitness=0;
  int i, j;

  // calculate total of fitness, used for roulette wheel selection
  for(i=0; i<POP_SIZE; i++) total_fitness+=fitness[i];
  total_fitness-=min_fitness*POP_SIZE;

  //create new population
  for(i=0; i<POP_SIZE; i++) {

    //the elitism_counter best individuals are simply copied to the new population
    if(i<elitism_counter) {
      for(j=0;j<GENOME_LENGTH;j++)
        newpop_bin[i][j]=pop_bin[(int)sortedfitness[i][1]][j];
    }
    //the other individuals are generated through the crossover of two parents
    else {

      //select non-elitist individual
      int ind1=0;
      if (ROULETTE_WHEEL==1) {
        double r=(double)rand()/(double)RAND_MAX;
        double fitness_counter=(sortedfitness[ind1][0]-min_fitness)/total_fitness;
        while( r > fitness_counter) {
          ind1++;
          fitness_counter+=(sortedfitness[ind1][0]-min_fitness)/total_fitness;
        }
      }
      else ind1=floor((double)rand()/(double)RAND_MAX*POP_SIZE*REPRODUCTION_RATIO);

      //if we will do crossover, select a second individual
      if ((double)rand()/(double)RAND_MAX < CROSSOVER_PROBABILITY) {
        int ind2=0;
        if (ROULETTE_WHEEL==1)
          do {
            double r=(double)rand()/(double)RAND_MAX;
            double fitness_counter=(sortedfitness[ind2][0]-min_fitness)/total_fitness;
            while(( r > fitness_counter) && (ind2 < POP_SIZE)){
              ind2++;
              fitness_counter+=(sortedfitness[ind2][0]-min_fitness)/total_fitness;
            }
          } while (ind1==ind2);
        else
          do {
            ind2=floor((double)rand()/(double)RAND_MAX*POP_SIZE*REPRODUCTION_RATIO);
          } while (ind1==ind2);
        ind1=(int)sortedfitness[ind1][1];
        ind2=(int)sortedfitness[ind2][1];
        crossover(ind1, ind2, newpop_bin[i]);
      }
      else { //if no crossover was done, just copy selected individual directly
        for(j=0;j<GENOME_LENGTH;j++) newpop_bin[i][j]=pop_bin[(int)sortedfitness[ind1][1]][j];
      }
    }
  }

  //mutate new population and copy back to pop
  for(i=0; i<POP_SIZE; i++) {
    if(i<elitism_counter) { //no mutation for elitists
      for(j=0;j<GENOME_LENGTH;j++)
        pop_bin[i][j]=newpop_bin[i][j];
    }
    else { //mutate others with probability per gene
      for(j=0;j<GENOME_LENGTH;j++)
        if(((double)rand()/(double)RAND_MAX)<MUTATION_PROBABILITY)
          pop_bin[i][j]=mutate(newpop_bin[i][j]);
        else
          pop_bin[i][j]=newpop_bin[i][j];
    }

    //reset fitness
    fitness[i]=-1;
  }
  return;
}
Esempio n. 12
0
void SimpleGA::evolve(Team *T) {
   Team *oldTeam, *newTeam, *delTeam;
   QArray<floatbot> botFitness;
   unsigned int teamSize, breed;
   int i;
   Bot *curbot;
   Bot *newbot1, *newbot2;

   oldTeam = T;
   newTeam = new Team;
   delTeam = new Team;

   teamSize = oldTeam->size();
   botFitness.resize(teamSize);
   for (i=0; i< (int)teamSize; i++) {
      curbot = oldTeam->bot(i);
      botFitness[i].fit = curbot->fitnessFunction();
      botFitness[i].bot = i;
   }
   botFitness.sort();

   // reverse fitness array
   for (i=0; i<(int)(teamSize/2); i++) {
      floatbot temp;
      temp.fit = botFitness[i].fit;
      temp.bot = botFitness[i].bot;
      botFitness.at(i).fit = botFitness.at(teamSize-i-1).fit;
      botFitness.at(i).bot = botFitness.at(teamSize-i-1).bot;
      botFitness.at(teamSize-i-1).fit = temp.fit;
      botFitness.at(teamSize-i-1).bot = temp.bot;
   }
   
   // add the good bots to the new team
   breed = teamSize / 2;                 // number of bots to breed
   if ( (breed/2)*2 != breed ) breed--;  // make sure its even
   for (i=0; i<(int)(teamSize - breed); i++) {
      // number of bots to throw out is the number bred, so keep the number not thrown out
      curbot = oldTeam->bot(botFitness[i].bot);
      newTeam->insertBot(curbot);
   }
   for (i=(teamSize - breed); i<(int)teamSize; i++) {
      // put bots to be deleted on a separate team
      curbot = oldTeam->bot(botFitness[i].bot);
      delTeam->insertBot(curbot);
   }
   while (oldTeam->size() > 0) {
      // remove bots from oldTeam
      curbot = oldTeam->removeBot(0);
   }
   while (delTeam->size() > 0) {
      // actually delete bots
      curbot = delTeam->removeBot(0);
      delete curbot;
   }
   
   // do the crossover of the best bots
   for (i=0; i<(int)breed; i+=2) {
      newbot1 = new Bot(oldTeam);
      newbot2 = new Bot(oldTeam);
      crossover(newTeam->bot(i), newTeam->bot(i+1), newbot1, newbot2);
      newTeam->insertBot(newbot1);
      newTeam->insertBot(newbot2);
   }
   
   // mutate a bot given the mutation rate
   for (i=0; i<(int)teamSize; i++) {
      double rnd = Random::randd(0,1);
      if (rnd < MutationRate) {
         curbot = newTeam->bot(i);
         curbot->mutateBot();
      }
   }
   
   // copy bots back into old team
   while (newTeam->size() > 0) {
      curbot = newTeam->removeBot(0);
      oldTeam->insertBot(curbot);
   }
   oldTeam->generations(oldTeam->generations() + 1);
   delete delTeam;
   delete newTeam;
}
Esempio n. 13
0
main()
{

  /*Some Local variables to this Problem (Counters And some other pointers*/

  int i,j,l,f,maxrank1;
  float *ptr,tot;
  FILE 
    *rep_ptr,
    *gen_ptr,
    *rep2_ptr,
    *end_ptr,
    *g_var,
    *lastit;
  /*File Pointers*/

  rep_ptr = fopen("output.out","w");
  gen_ptr =fopen("all_fitness.out","w");
  rep2_ptr = fopen("ranks.out","w");
  end_ptr = fopen("final_fitness.out","w");
  g_var = fopen("final_var.out","w");
  lastit = fopen("plot.out","w");
  /*Opening the files*/

  old_pop_ptr = &(oldpop);

  nmut = 0;
  ncross = 0;

  /*Get the input from the file input.h*/
  input(rep_ptr);

  fprintf(rep_ptr,"Results in a file\n");
  fprintf(end_ptr,"# Last generation population (Feasible and non-dominated)\n");
  fprintf(end_ptr,"# Fitness_vector (first %d)  Constraint_violation (next %d)  Overall_penalty\n",nfunc,ncons);
  fprintf(g_var,"#Feasible Variable_vectors for non-dominated solutions at last generation\n");
  fprintf(g_var,"# Real (first %d)  Binary (next %d)\n",nvar,nchrom);
  fprintf(lastit,"# Feasible and Non-dominated Objective Vector\n");

  /*Initialize the random no generator*/
  warmup_random(seed);

   /*Binary Initializaton*/
  if (nchrom > 0)
    init(old_pop_ptr);  
  if (nvar > 0)
    realinit(old_pop_ptr);
  
  old_pop_ptr = &(oldpop);

  // decode binary strings
  decode(old_pop_ptr); 

  old_pop_ptr = &(oldpop);
  new_pop_ptr = &(newpop);
  
  for(j = 0;j < popsize;j++)
    {
      /*Initializing the Rank array having different individuals
	at a particular  rank to zero*/
       old_pop_ptr->rankno[j] = 0;
       new_pop_ptr->rankno[j] = 0;
    }
  
  old_pop_ptr = &(oldpop);
  
  func(old_pop_ptr); 
  /*Function Calculaiton*/
  
  fprintf(rep_ptr,"----------------------------------------------------\n");
  fprintf(rep_ptr,"Statistics at Generation 0 ->\n");
  fprintf(rep_ptr,"--------------------------------------------------\n");
  
  /********************************************************************/
  /*----------------------GENERATION STARTS HERE----------------------*/
  for (i = 0;i < gener;i++)
    {
      printf("Generation = %d\n",i+1);
      old_pop_ptr = &(oldpop);
      mate_pop_ptr = &(matepop);
      fprintf(rep_ptr,"Population at generation no. -->%d\n",i+1);
      fprintf(gen_ptr,"#Generation No. -->%d\n",i+1);
      fprintf(gen_ptr,"#Variable_vector  Fitness_vector Constraint_violation Overall_penalty\n");
      
      /*--------SELECT----------------*/
      nselect(old_pop_ptr ,mate_pop_ptr );
      
      new_pop_ptr = &(newpop);
      mate_pop_ptr = &(matepop);
      
      /*CROSSOVER----------------------------*/      
      if (nchrom > 0) 
	{
	  
	  if(optype == 1)
	    {
	      crossover(new_pop_ptr ,mate_pop_ptr );
	      /*Binary Cross-over*/
	    }
	  
	  if(optype == 2)
	    {
	      unicross(new_pop_ptr ,mate_pop_ptr );
	      /*Binary Uniform Cross-over*/
	    }
	}
      if (nvar > 0) 
	realcross(new_pop_ptr ,mate_pop_ptr );
      /*Real Cross-over*/
      
      
      /*------MUTATION-------------------*/
      new_pop_ptr = &(newpop);
      
      if (nchrom > 0)
	mutate(new_pop_ptr );
      /*Binary Mutation */
      
      if (nvar > 0)
	real_mutate(new_pop_ptr );
      /*Real Mutation*/
      
      new_pop_ptr = &(newpop);
      
      /*-------DECODING----------*/
      if(nchrom > 0)
	decode(new_pop_ptr );
      /*Decoding for binary strings*/
      
      /*----------FUNCTION EVALUATION-----------*/
      new_pop_ptr = &(newpop);
      func(new_pop_ptr );
      
      /*-------------------SELECTION KEEPING FRONTS ALIVE--------------*/
      old_pop_ptr = &(oldpop);
      new_pop_ptr = &(newpop);
      mate_pop_ptr = &(matepop);
      
      /*Elitism And Sharing Implemented*/
      keepalive(old_pop_ptr ,new_pop_ptr ,mate_pop_ptr,i+1);      
      
      mate_pop_ptr = &(matepop);
      if(nchrom > 0)
	decode(mate_pop_ptr );
      
      mate_pop_ptr = &(matepop);
      /*------------------REPORT PRINTING--------------------------------*/  
      report(i ,old_pop_ptr ,mate_pop_ptr ,rep_ptr ,gen_ptr, lastit );
      
      /*==================================================================*/
      
      /*----------------Rank Ratio Calculation------------------------*/
      new_pop_ptr = &(matepop);
      old_pop_ptr = &(oldpop);
      
      /*Finding the greater maxrank among the two populations*/
      
      if(old_pop_ptr->maxrank > new_pop_ptr->maxrank)
	maxrank1 = old_pop_ptr->maxrank;
      else 
	maxrank1 = new_pop_ptr->maxrank;

      fprintf(rep2_ptr,"--------RANK AT GENERATION %d--------------\n",i+1);
      fprintf(rep2_ptr,"Rank old ranks   new ranks     rankratio\n");

      for(j = 0;j < maxrank1 ; j++)
	{ 
	  /*Sum of the no of individuals at any rank in old population 
	    and the new populaion*/
	  
	  tot = (old_pop_ptr->rankno[j])+ (new_pop_ptr->rankno[j]);
	  
	  /*Finding the rank ratio for new population at this rank*/
	  
	  new_pop_ptr->rankrat[j] = (new_pop_ptr->rankno[j])/tot;
	  
	  /*Printing this rank ratio to a file called ranks.dat*/
	  
	  fprintf(rep2_ptr," %d\t  %d\t\t %d\t %f\n",j+1,old_pop_ptr->rankno[j],new_pop_ptr->rankno[j],new_pop_ptr->rankrat[j]);
	  
	}
      
      fprintf(rep2_ptr,"-----------------Rank Ratio-------------------\n");
      /*==================================================================*/
      
      /*=======Copying the new population to old population======*/
      
      old_pop_ptr = &(oldpop);
      new_pop_ptr = &(matepop);

      for(j = 0;j < popsize;j++)
	{
	  old_pop_ptr->ind_ptr = &(old_pop_ptr->ind[j]);
	  new_pop_ptr->ind_ptr = &(new_pop_ptr->ind[j]);
	  if(nchrom > 0)
	    {
	      /*For Binary GA copying of the chromosome*/
	      
	      for(l = 0;l < chrom;l++)
		old_pop_ptr->ind_ptr->genes[l]=new_pop_ptr->ind_ptr->genes[l];
	      
	      for(l = 0;l < nchrom;l++)
		old_pop_ptr->ind_ptr->xbin[l] = new_pop_ptr->ind_ptr->xbin[l];
	    }
	  if(nvar > 0)
	    {
	      /*For Real Coded GA copying of the chromosomes*/
	      for(l = 0;l < nvar;l++)
		old_pop_ptr->ind_ptr->xreal[l] = new_pop_ptr->ind_ptr->xreal[l];
	    }
	  
	  /*Copying the fitness vector */	  
	  for(l = 0 ; l < nfunc ;l++)
	    old_pop_ptr->ind_ptr->fitness[l] = new_pop_ptr->ind_ptr->fitness[l];
	  
	  /*Copying the dummy fitness*/
	  old_pop_ptr->ind_ptr->cub_len = new_pop_ptr->ind_ptr->cub_len;
	  
	  /*Copying the rank of the individuals*/
	  old_pop_ptr->ind_ptr->rank = new_pop_ptr->ind_ptr->rank;
	  
	  /*Copying the error and constraints of the individual*/
	  
	  old_pop_ptr->ind_ptr->error = new_pop_ptr->ind_ptr->error;
	  for(l = 0;l < ncons;l++)
	    {
	      old_pop_ptr->ind_ptr->constr[l] = new_pop_ptr->ind_ptr->constr[l];
	    }
	  
	  /*Copying the flag of the individuals*/
	  old_pop_ptr->ind_ptr->flag = new_pop_ptr->ind_ptr->flag;
	}   // end of j
      
      maxrank1 = new_pop_ptr->maxrank ;
	  
      /*Copying the array having the record of the individual 
	at different ranks */
      for(l = 0;l < popsize;l++)
	{
	  old_pop_ptr->rankno[l] = new_pop_ptr->rankno[l];
	}
      
      /*Copying the maxrank */
      old_pop_ptr->maxrank = new_pop_ptr->maxrank;
      
      /*Printing the fitness record for last generation in a file last*/
      if(i == gener-1)
       	{  // for the last generation 
	  old_pop_ptr = &(matepop);
	  for(f = 0;f < popsize ; f++) // for printing
	    {
	      old_pop_ptr->ind_ptr = &(old_pop_ptr->ind[f]);
	      
	      if ((old_pop_ptr->ind_ptr->error <= 0.0) && (old_pop_ptr->ind_ptr->rank == 1))  // for all feasible solutions and non-dominated solutions
		{
		  for(l = 0;l < nfunc;l++)
		    fprintf(end_ptr,"%f\t",old_pop_ptr->ind_ptr->fitness[l]);
		  for(l = 0;l < ncons;l++)
		    {
		      fprintf(end_ptr,"%f\t",old_pop_ptr->ind_ptr->constr[l]);
		    }
		  if (ncons > 0)
		    fprintf(end_ptr,"%f\t",old_pop_ptr->ind_ptr->error);
		  fprintf(end_ptr,"\n");
		  
		  if (nvar > 0)
		    {
		      for(l = 0;l < nvar ;l++)
			{
			  fprintf(g_var,"%f\t",old_pop_ptr->ind_ptr->xreal[l]);
			}
		      fprintf(g_var,"  ");
		    }
		  
		  if(nchrom > 0)
		    {
		      for(l = 0;l < nchrom;l++)
			{
			  fprintf(g_var,"%f\t",old_pop_ptr->ind_ptr->xbin[l]);
			}
		    }
		  fprintf(g_var,"\n");
		}  // feasibility check
	    } // end of f (printing)
	  
	} // for the last generation
    }  // end of i 

  /*                   Generation Loop Ends                                */
  /************************************************************************/
  
  fprintf(rep_ptr,"NO. OF CROSSOVER = %d\n",ncross);
  fprintf(rep_ptr,"NO. OF MUTATION = %d\n",nmut);
  fprintf(rep_ptr,"------------------------------------------------------------\n");
  fprintf(rep_ptr,"---------------------------------Thanks---------------------\n");
  fprintf(rep_ptr,"-------------------------------------------------------------\n");
  printf("NOW YOU CAN LOOK IN THE FILE OUTPUT2.DAT\n");
  
  /*Closing the files*/
  fclose(rep_ptr);
  fclose(gen_ptr);
  fclose(rep2_ptr);
  fclose(end_ptr);
  fclose(g_var);
  fclose(lastit);
}
Esempio n. 14
0
int main(int argc, char *argv[])
{
	// Need to change to 3. need to remove the logging.
	if (argc != 4)
	{
		printf("Usage: ./maxcut <input data path> <output data path> <log file>\n");
		exit(-1);
	}
	
	// Need to remove when submitting.
	log_file = fopen(argv[3], "w");
	fprintf(log_file, "rate, elasped time (s), max val, avg val\n");

	start_time = get_seconds();

	in 		= fopen(argv[1], "r");
	out 	= fopen(argv[2], "w");
	int i, j, v1, v2, w;	// (v1, v2) is the vertex and w is the weight

	fscanf(in, "%d %d\n", &num_of_vertex, &num_of_edge);
	
	int edge[num_of_vertex+1][num_of_vertex+1];
	
	for (i=0; i<=SIZE; i++)
		for (j=0; j<=SIZE; j++)
			edge[i][j] = 0;

	while (fscanf(in, "%d %d %d\n", &v1, &v2, &w) != EOF)
	{
		edge[v1][v2] = w;
		edge[v2][v1] = w;
	}
	
	init_population();
	init_offsprings();
	init_cost(edge);
	sort_population();
	init_crossover();

	int p1, p2;

	while (!(stop_condition()))
	{
		generation++;
		for (i=1; i<=K; i++)
		{
			selection(&p1, &p2);
			crossover(i, p1, p2);
			mutation(i);
			local_optimization(i, edge);
		}

		replacement(edge);

		sort_population();
	}

	for (i=1; i<=SIZE; i++)
	{
		if (population[N]->ch[i] == 1)
			fprintf(out, "%d ", i);
	}

	free_population();

	fclose(in);
	fclose(out);

 	printf("N: %d, K: %d, S_RATE: %lf, M_THRE: %lf, P0: %lf, POINTS: %d, K_FIT: %d, T: %lf\n", N,     K, S_RATE, M_THRE, P0, POINTS, K_FIT, T);


	return 0;
}
Esempio n. 15
0
File: main.c Progetto: g1ll/ga_c
/**
 * <h3>Algoritmos Genéticos</h3>
 * <p>A função ga_fo_01 tem como objetivo usar uma implementação simples de GA para
 * otimizar a função <i>F(x)=x*sin(10*pi*x)+1<i> em um espaço de busca definido.</p>
 * @file main.c
 * @version 0.0
 * @autor Gill Velleda Gonzales
 * @param a Início do espaço de busca 
 * @param step Valor de incremento
 * @param b Fim do espaço de busca
 * @param otimizacao 0 Minimiza a FO != 0 Maximiza
 * @pop_size tamanho da população (bug máximo 12 indivíduos)
 * @return  
 * Valor otimizado de <i><b>fo_01</b></i> no espaço definido por <b>a</b> até  <b>b</b> passo <b>step</b>
 * 
 * @ToDo
 * 
 *   
 */
long double ga_fo_01(double a, double step, double b, int otimizacao, int pop_size) {

    //Inicialização
    int **pop,
            **pop_mat, //População Intermediaria
            size_pop = pop_size, //População
            genes = 12, //Tamanho de Cromossomos (Cadeia de Bits)
            geracao = 1, i, j,
            count_ev = 0, //Contador de não-evoluções ou gerações iguais que não evoluirão;
            nev_max = 10, //Número máximo de populações iguais que não evoluirão, critério de parada
            *cr_opt;
    float *v_ap,
            taxa_cros = 0.9,
            taxa_mutate = 0.3;



    printf("\nAlgoritmo Genético Processando");
    //Espaço de Busca
    printf("\nEspaço de busca de %.3f a %.3f incrementado de %.3f", a, b, step);
    //Gerando a população
    printf("\nGerando a População ...\nCromossos: 12 genes binários\nPopulação: %d indivíduos", size_pop);
    pop = gerarPopIni(size_pop, genes, a, step, b);
    //LOOP
    do {
        if (geracao > 1)
            free(pop_mat); //Liberando memória - Descarta a população de Pais
        //Avalia População
        printf("\nAvaliando a população (Geração: %d)", geracao);

        v_ap = avaliarPop(pop, size_pop, genes, a, b);
        //Selecionar mais aptos
        printf("\n Selecionando mais aptos:\n\t-gerando mating-pool\n");
        pop_mat = selecaoTorneio(pop, v_ap, size_pop, genes, otimizacao);
        printf("\n População Original - Geracao %d:\n", geracao);
        printPop(pop, size_pop, genes);
        printf("\n\n População Intermediária:\n");
        printPop(pop_mat, size_pop, genes);
        free(pop); //Liberando memória - Descarta a população original
        //Operações de Crossover e Mutação
        pop = crossover(pop_mat, taxa_cros, size_pop, genes);
        printf("\n\n Nova Geração pós-cruzamentos:");
        printPop(pop, size_pop, genes);        
        //Mutação
        pop = mutate(pop, taxa_mutate, size_pop, genes);
        printf("\n\n Nova Geração pós-mutações:");
        printPop(pop, size_pop, genes);
        //Geração de nova população
        geracao++;
        //count_nev = final_ga(pop, v_ap, size_pop, genes, count_nev);
        count_ev = final_ga(pop_mat, v_ap, size_pop, genes, count_ev);
        printf("\t-----------CONTADOR %d----------\n", count_ev);
        printf("\n||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\n");
        if (count_ev == nev_max) {
            /* aloca espaço para o cromossomo otimo */
            cr_opt = (int *) calloc(genes, sizeof (int));
            cr_opt = getOtimo(pop_mat, otimizacao, size_pop);
        }
    } while (count_ev < nev_max); //&& geracao <= 100);
    //FIM LOOP
    
     printf("\n GA- Finalizado:\n\tPopulação dos mais aptos:\n");
    printPop(pop_mat, size_pop, genes);
    printf("\n GA- Finalizado:\n\tx = %.3f Valor ótimo;\n\t y = %.3f", bitsToFloat(cr_opt), fo_01(bitsToFloat(cr_opt)));
    printf("\n Tamanho da População: %d", size_pop);
    printf("\n Genes por Cromossomos: %d", genes);
    printf("\n Taxa de Cruzamento: %.1f", taxa_cros);
    printf("\n Taxa de Mutação: %.1f", taxa_mutate);
    printf("\n Última Geração: %d:\n", geracao);
    printf("\n\n");
}
Esempio n. 16
0
int main(int argc, char **argv)
{
	int maxprims, maxfigs, maxpts, state, maxindivs, namelen;
	int nfigs, nprims, npts, setsize, iters;
	int ext;
	struct Individ *indivs, tmp;
	struct Figure *figs, *figset;
	char *str;
	ssize_t chread;
	size_t n;
	int i, j, k, m, nindivs;
	struct NestAttrs attrs;
	
	str = NULL;
	n = 0;

	maxfigs = 128;
	namelen = 2048;
	state = STATE_NEWFIG;
	nfigs = nprims = npts = 0;
	figs = (struct Figure*)xmalloc(sizeof(struct Figure) * maxfigs);

	while ((chread = getline(&str, &n, stdin)) != -1) {
		double x, y;
		trim(str);

		if (state == STATE_NEWFIG) {
			figs[nfigs].name = (char*)xmalloc(sizeof(char) * namelen);
			sscanf(str, "%s %d %d\n", figs[nfigs].name, &figs[nfigs].quant, &figs[nfigs].angstep);
			state = STATE_PRIM;
			
			maxpts = 2048;
			maxprims = 128;

			figs[nfigs].prims = (struct Primitive*)xmalloc(sizeof(struct Primitive) * maxprims); 
			figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);

	//		free(str);
			str = NULL;
			continue;
		}
		
		if (strcmp(str, FIG_SEPAR) == 0) {
			state = STATE_NEWFIG;
			figs[nfigs].prims[nprims].npts = npts;
			nprims++;
			figs[nfigs].id = nfigs;
			figs[nfigs].nprims = nprims;
			nfigs++;
			
			if (nfigs == maxfigs) {
				maxfigs *= 2;
				figs = (struct Figure*)xrealloc(figs, sizeof(struct Figure) * maxfigs);
			}
			
			nprims = 0;
			npts = 0;

	//		free(str);
			str = NULL;
			continue;
		}

		if (strcmp(str, PRIM_SEPAR) == 0) {
			figs[nfigs].prims[nprims].npts = npts;
			nprims++;
			if (nprims == maxprims) {
				maxprims *= 2;
				figs[nfigs].prims = (struct Primitive*)xrealloc(figs[nfigs].prims, sizeof(struct Primitive) * maxprims);
			}

			maxpts = 2048;
			figs[nfigs].prims[nprims].pts = (struct Point*)xmalloc(sizeof(struct Point) * maxpts);
			npts = 0;

	//		free(str);
			str = NULL;
			continue;
		}
		
		sscanf(str, "%lf %lf\n", &x, &y);
		
		figs[nfigs].prims[nprims].pts[npts].x = x;
		figs[nfigs].prims[nprims].pts[npts].y = y;
		npts++;

		if (npts == maxpts) {
			maxprims *= 2;
			figs[nfigs].prims[nprims].pts = (struct Point*)xrealloc(figs[nfigs].prims[nprims].pts, sizeof(struct Point) * maxpts);
		}

	//	free(str);
		str = NULL;
	}

	for (i = 0; i < nfigs; i++) {
		figinit(&figs[i]);
	}


	attrs.width = atof(argv[1]);
	attrs.height = atof(argv[2]);
	attrs.type = ROTNEST_DEFAULT;
	attrs.logfile = fopen("./logfile", "w+");

		
	figset = makeset(figs, nfigs, &setsize);
	qsort(figset, setsize, sizeof(struct Figure), figcmp);

	maxindivs = 1024;
	indivs = (struct Individ*)xmalloc(sizeof(struct Individ) * maxindivs);
	indivs[0].genom = (int*)xmalloc(sizeof(int) * setsize);
	indivs[0].gensize = 0;

	rotnest(figset, setsize, &indivs[0], &attrs);
			
	nindivs = 1;	
	ext = 0;
	iters = atoi(argv[3]);
	for (i = 0; i < iters && !ext; i++) {
		int nnew = 0, equal = 0, oldn;
		
		printf("nindivs=%d\n", nindivs);
		for (j = 0; j < 1; j++) {
			printf("ind=%d height=%lf gensize=%d genom: ", i, indivs[j].height, indivs[j].gensize);
			for (k = 0; k < indivs[j].gensize; k++) { 
				printf("%d ", indivs[j].genom[k]);
			}
			printf("\n");
		}

		printf("\n");

		oldn = nindivs;
		for (j = 0; j < oldn - 1 && nnew < 30; j++) {
			struct Individ heirs[2];
			if (indivs[j].gensize == indivs[j + 1].gensize) {
				int res;
				res = crossover(&indivs[j], &indivs[j + 1], &heirs[0], setsize);
				crossover(&indivs[j + 1], &indivs[j], &heirs[1], setsize);
	
				if (res < 0) {
					break;
				}
			}
			else {
				break;
			}

			for (k = 0; k < 2; k++) {
				for (m = 0; m < nindivs; m++) {
					equal = gensequal(&heirs[k], &indivs[m]) || gensequal2(&heirs[k], &indivs[m], figset);
					if (equal) {
						break;
					}
				}
			

				if (!equal) {
					nnew++;
					rotnest(figset, setsize, &heirs[k], &attrs);
					indivs[nindivs] = heirs[k];
					nindivs++;

					if (nindivs == maxindivs) {
						maxindivs *= 2;
						indivs = (struct Individ*)xrealloc(indivs, sizeof(struct Individ) * maxindivs);
					}
				} else {
					destrindiv(&heirs[k]);
				}
			}
		}
		
	
		
		equal = 0;
		while (nnew == 0) {
			int res;
			res = mutate(&indivs[0], &tmp, setsize);
			if (res < 0) {
				ext = 1;
				break;
			}
			equal = 0;
			for (j = 0; j < nindivs; j++) {
				equal = gensequal(&tmp, &indivs[j]) || gensequal2(&tmp, &indivs[j], figset);
				if (equal) {
					break;
				}
			}
			if (!equal) {
				nnew++;
				rotnest(figset, setsize, &tmp, &attrs);
				indivs[nindivs] = tmp;
				nindivs++;

				if (nindivs == maxindivs) {
					maxindivs *= 2;
					indivs = (struct Individ*)xrealloc(indivs, sizeof(struct Individ) * maxindivs);
				}
			} else {
				destrindiv(&tmp);
			}
		}
		qsort(indivs, nindivs, sizeof(struct Individ), gencmp);
	}
	


	for (i = 0; i < indivs[0].npos; i++) {
		double a, b, c, d, e, f;
		a = indivs[0].posits[i].fig.mtx[0][0];
		b = indivs[0].posits[i].fig.mtx[1][0];
		c = indivs[0].posits[i].fig.mtx[0][1];
		d = indivs[0].posits[i].fig.mtx[1][1];
		e = indivs[0].posits[i].fig.mtx[0][2];
		f = indivs[0].posits[i].fig.mtx[1][2];

		printf("%s\n", indivs[0].posits[i].fig.name);
		printf("matrix(%lf, %lf, %lf, %lf, %lf, %lf)\n:\n", a, b, c, d, e, f);
	}

//	ppos2file("./drawposits", indivs[0].posits, indivs[0].npos);
	
	return 0;
}
Esempio n. 17
0
/**
 * Main method of genetic algorithm.
 * @param config Struct with configuraiton parameters like population size, number of gens, etc...
 * @see struct Chromosome_configuration
 */
int genetic_main(Ptr_config config)
{
#ifdef TRACE
    printf("---> genetic_main.\n");
    fflush(stdout);
#endif

    const int TOTAL_CHROM = config->total_chrom;
    const int MAX_ITER = config->max_iter;
    const int MAX_REP_MEJOR = config->max_iter_best;
    const int CHROMOSOME_LENGTH = config->chrom_length;

    int rep_best, fin,  ale1, ale2, eti1, eti2, iter, i, validos, np;
    double best;
    Ptr_Chromosome *List_Chromosome; // Array of chromosmes. Population.

    rep_best = 10;
    fin = 0;
    ale1 = 0;
    ale2 = 0;
    eti1 = 0;
    eti2 = 0;

    iter = 0;
    i = 0;
    validos = 0; /**< Percentage of valid chromosomes */

    // Time measurement variables
    struct timeval *tv;
    struct timezone *tz;
    long tf, ti, si, sf;
    double tiempo, mut;

    tv = (struct timeval *)malloc(sizeof(struct timeval));
    tz = NULL;

    gettimeofday(tv, tz);
    si = (tv->tv_sec);
    ti = (tv->tv_usec);
    ti = si * 1000000 + ti;

    srand (time (NULL));

    /*
     * ##########################################
     * ###### GENERATE INITIAL POPULATION #######
     * ##########################################
     */

    List_Chromosome = (Ptr_Chromosome*)malloc(TOTAL_CHROM * sizeof(Ptr_Chromosome));


// Canditate loop to be paralelized with OpenMP
    for ( i = 0 ; i < TOTAL_CHROM ; i++ )
    {
        List_Chromosome[i] = create_chromosome(i, CHROMOSOME_LENGTH);
    }

    rep_best = 0;
    best = -1.0; //se le da un valor que no tiene ninguno para que no coincida

// ######### MAIN LOOP ##########
    while ( fin == 0 )
    {

        /*
         * ###########################################
         * ###### EVALUATION AND CLASSIFICATION ######
         * ###########################################
         */

        // Canditate loop to be paralelized with OpenMP
        for ( i = 0  ; i < TOTAL_CHROM ; i++ )
        {
            if ( ((List_Chromosome[i])->evaluation == BAD_CHROM) && (good_chromosome(List_Chromosome[i], CHROMOSOME_LENGTH) == 1) )
            {
                List_Chromosome[i]->evaluation = evaluate_chromosome(List_Chromosome[i], CHROMOSOME_LENGTH);
            };
        };
        classify_chromosome(List_Chromosome, TOTAL_CHROM);
        best = List_Chromosome[0]->evaluation;

        /*
         * #####################################
         * ###### CHROMOSOME REPRODUCTION ######
         * #####################################
         */
#ifdef TRACE
        printf("Reproduccion de los cromosomas\n");
        fflush(stdout);
#endif

        // Canditate loop to be paralelized with OpenMP
        for ( i = TOTAL_CHROM / 2 ; i < TOTAL_CHROM - 1 ; i = i + 2 )
        {
            // Elimination of the worst half part of the population
            eti1 = List_Chromosome[i]->id;
            eti2 = List_Chromosome[i + 1]->id;
            ale1 = (int)(rand() % (TOTAL_CHROM / 2));
            ale2 = (int)(rand() % (TOTAL_CHROM / 2));

            free_chromosome(List_Chromosome[i]);
            free_chromosome(List_Chromosome[i + 1]);
            List_Chromosome[i] = NULL;
            List_Chromosome[i + 1] = NULL;

            crossover(List_Chromosome[ale1], List_Chromosome[ale2], &List_Chromosome[i], &List_Chromosome[i + 1], CHROMOSOME_LENGTH, ONE_POINT_CROSS);
            List_Chromosome[i]->id = eti1;
            List_Chromosome[i + 1]->id = eti2;
        }

        /*
         * ####################################
         * #######       MUTATION      ########
         * ####################################
         */
        mut = (double)(rand() % (100));
        if ( mut < 10 ) //el 10% de que haya mutacion
        {
            ale1 = (int)(rand() % (TOTAL_CHROM / 2));
            mutate(List_Chromosome[ale1], CHROMOSOME_LENGTH, BIT_STRING_MUTATION);
        };

        iter++;

        // CHECK END CONDITIONS
        if ((best == (List_Chromosome[0])->evaluation) && (best != BAD_CHROM))
            rep_best++;
        else
        {
            rep_best = 0;
            best = (List_Chromosome[0])->evaluation;
        };

        if ( (rep_best == MAX_REP_MEJOR) || (iter == MAX_ITER)   )
            fin = 1;

        /*
         * #####################################################################
         * ###### EVALUACION Y CLASIFICACION DESPUES DE CRUCE Y MUTACION. ######
         * #####################################################################
         */

// Canditate loop to be paralelized with OpenMP
        for ( i = 0  ; i < TOTAL_CHROM ; i++ )
        {
            if ( ((List_Chromosome[i])->evaluation == BAD_CHROM) && (good_chromosome(List_Chromosome[i], CHROMOSOME_LENGTH) == 1) )
            {
                List_Chromosome[i]->evaluation = evaluate_chromosome(List_Chromosome[i], CHROMOSOME_LENGTH);
            };
        };
        classify_chromosome(List_Chromosome, TOTAL_CHROM);

        // PRINT 3 BEST CHROMOSOMES
        printf("%d ITERATION. 3 BEST CHROMOSOMES:\n", iter);
        for ( i = 0 ; i < 3 ; i++)
        {
            show_chromosome(List_Chromosome[i], CHROMOSOME_LENGTH);
        }

    };// ########### END OF MAIN LOOP ###########


    // TIME MEASUREMENT
    gettimeofday(tv, tz);
    sf = (tv->tv_sec);
    tf = (tv->tv_usec);
    tf = sf * 1000000 + tf;
    tiempo = (1.0 * tf - 1.0 * ti) / 1000000.0;
    printf("\nExecution time T=%lf s.\n", tiempo);
    fflush(stdout);

    // CALCULATE PERCENTAGE OF VALID CHROMOSOMES.
    for ( i = 0 ; i < TOTAL_CHROM ; i++ )
        if ( List_Chromosome[i]->evaluation != BAD_CHROM )
            validos++;
    printf("%d%% of valid chromosomes.\n", (validos * 100) / TOTAL_CHROM);

    // Free memory
    for ( i = 3 ; i < TOTAL_CHROM ; i++ )
        free_chromosome(List_Chromosome[i]);
    List_Chromosome = realloc(List_Chromosome, 3 * sizeof(struct Chromosome));
}
Esempio n. 18
0
/*
 * evolution of the group, including the process of
 * select parent, crossover and mutation
 */
void evolve(Group* grp)
{
	select_parent(grp);
	crossover(grp);
	mutate(grp);
}
Esempio n. 19
0
SEXP GADEM_Analysis(SEXP sequence,SEXP sizeSeq, SEXP accession, SEXP Rverbose,SEXP RnumWordGroup,SEXP RnumTop3mer,SEXP RnumTop4mer,SEXP RnumTop5mer,SEXP RnumGeneration,SEXP RpopulationSize, SEXP RpValue,SEXP ReValue,SEXP RextTrim,SEXP RminSpaceWidth,SEXP RmaxSpaceWidth,SEXP RuseChIPscore,SEXP RnumEM,SEXP RfEM, SEXP RwidthWt,SEXP RfullScan, SEXP RslideWinPWM,SEXP RstopCriterion,SEXP RnumBackgSets,SEXP RweightType,SEXP RbFileName,SEXP RListPWM,SEXP RminSites,SEXP RmaskR,SEXP Rnmotifs) 
{
  char *bFileName;
  
  SEXP ResultsGadem;
  SEXP RSpwm;
  PROTECT(ResultsGadem=NEW_LIST(100));  
  
  int increment=0;
  
  double testrand;
  
  //Number of sequences
  int numSeq = INTEGER_VALUE(sizeSeq);
  // const
//  char *Fastaheader[size];
  int incr=0;
  
  int longueur=length(sequence);
  int IncrementTemp=0;
  
  // basic settings/info
  int maxSeqLen,*seqLen;       		 // sequence info	
  double aveSeqLen;                      // sequence info
  char **seq,**rseq;
  int *geneID;         			 // sequence info
  char **oseq,**orseq;                   // copy of the original sequences
  char **sseq,**rsseq;                   // simulated seqs.
  double *bfreq1, *bfreq0=NULL;                // base frequencies
  double *ChIPScore;                     // chip score
  int maskR;				 // mask simple repeats before running the algorithm
    
  // pwms
  double ***pwm;                         // initial population of PWMs from spaced dyads
  int *pwmLen;                           // initial pwm lengths
  double **opwm2;                        // EM-derived PWM
  double ***opwm;                        // observed PWMs from identified sites
  double ***epwm;                        // em-optimized PWMs
  double **logepwm;                      // log(em-optimized PWM)
  int *pwmnewLen;                        // final motif length after extending to both ends
  
  // llr score distr.
  Pgfs *llrDist;                         // llr distribution from pgf method
  int llrDim;                            // llr distribution dimension
  int **ipwm;                            // integer pwm for computing llr score distribution
  
  // EM, motif, sites
  double pvalueCutoff;                   // user input, used to determine score cutoff based on ipwm
  int *scoreCutoff;                      // pwm score cutoff for the corresponding p-value cutoff
  double logev;                          // log of E-value of a motif;
  int useChIPscore;                      // indicator for using ChIP-seq score for seq. selection for EM
  int numEM;                             // number of EM steps
  double E_valueCutoff;                  // log E-value cutoff
  //int nsitesEM;                          // number of binding sites in sequences subjected to EM
  int minsitesEM;                        // minimal number of sites in a motif in EM sequences
  int *nsites;                           // number of binding sites in full data
  int minsites;                          // minimal number of sites in a motif in full data
  Sites **site;                          // binding sites in all sequences
  int motifCn;                           // number of motifs sought and found
  int extTrim;
  int noMotifFound;                      // none of the dyads in the population resulted in a motif
  char **pwmConsensus;                   // consensus sequences of motifs
  double pwmDistCutoff;                  // test statistic for motif pwm similarity
  char *uniqMotif;                       // motifs in a population unique or not
  int numUniq;                           // number of unique motifs in a population
  int slideWinPWM;                       // sliding window for comparing pwm similarity
  int widthWt;                           // window width in which nucleotides are given large weights for PWM optimization
  int fullScan;                          // scan scan on the original sequences or masked sequences
  
  // background
  int numBackgSets;
  
  // weights
  double **posWeight;                    // spatial weights
  int weightType;                        // four weight types 0, 1, 2, 3, or 4
  
  // words for spaced dyad
  Words *word;                           // top-ranked k-mers as the words for spaced dyads
  int numTop3mer,numTop4mer,numTop5mer;  // No. of top-ranked k-mers as words for dyads
  int maxWordSize;                       // max of the above three
  int numWordGroup;                      // number of non-zero k-mer groups
  int minSpaceWidth,maxSpaceWidth;       // min and max width of spacer of the spaced dyads
  Chrs **dyad;                           // initial population of "chromosomes"
  char **sdyad;                          // char of spaced dyads
  
  // GA
  int populationSize,numGeneration;      // GA parameters
  double maxpMutationRate;
  Fitness *fitness;                      // "chromosome" fitness
  Wheel *wheel;                          // roulette-wheel selection
  
  // to speed up only select a subset of sequences for EM algorithm
  double fEM;                            // percentage of sequences used in EM algorithm
  int numSeqEM;                          // number of sequences subject to EM
  char *Iseq;                            // Indicator if a sequence is used in EM or not
  int *emSeqLen;                         // length of sequences used in EM
  double *maxpFactor;
  
  int numCycle;                          // number of GADEM cycles
  int generationNoMotif;                 // maximal number of GA generations in a GADEM cycle resulted in no motifs
  
  // mis.
  //seed_t  seed;                          // random seed
  int motifCn2,id,numCycleNoMotif,verbose,minminSites,nmotifs;
  int startPWMfound,stopCriterion;
  char *mFileName,*oFileName,*pwmFileName,*tempRbFileName;
  time_t start;
  int cn[4],bcn[4],*seqCn,*bseqCn,avebnsites,avebnsiteSeq,totalSitesInput;
  int i; 
  int ii=0;
  int jjj=0;
  
  /*************/
  FILE * output = fopen("output.txt", "w"); 
  /*************/
  
  GetRNGstate();
  

  mFileName=alloc_char(500);         mFileName[0]='\0';
  oFileName=alloc_char(500);         oFileName[0]='\0';
  pwmFileName=alloc_char(500);       pwmFileName[0]='\0';
  bFileName=alloc_char(500);         bFileName[0]='\0';
  //tempRbFileName=alloc_char(500);    tempRbFileName[0]='\0';
  seq=NULL; aveSeqLen=0; maxSeqLen=0; 
  //minsites=-1; 
  
  startPWMfound=0;    

  maxSeqLen=0;
  for(incr=1;incr<longueur;incr=incr+2)
  { 
    if (length(STRING_ELT(sequence,(incr)))>maxSeqLen) maxSeqLen=length(STRING_ELT(sequence,(incr))); 
  }
//  fprintf(output,"maxLength=%d",maxSeqLen);
//  exit(0);
  seq=alloc_char_char(numSeq,maxSeqLen+1);
  for(incr=1;incr<longueur;incr=incr+2)
  { 
    for (int j=0; j<length(STRING_ELT(sequence,(incr))); j++)
    {
      seq[IncrementTemp][j]=CHAR(STRING_ELT(sequence,(incr)))[j];
    }
    IncrementTemp++;
  }
  
  
  verbose=LOGICAL_VALUE(Rverbose);
  numWordGroup=INTEGER_VALUE(RnumWordGroup);
  minsites=INTEGER_VALUE(RminSites);
  numTop3mer=INTEGER_VALUE(RnumTop3mer);
  numTop4mer=INTEGER_VALUE(RnumTop4mer);
  numTop5mer=INTEGER_VALUE(RnumTop5mer);
  numGeneration=INTEGER_VALUE(RnumGeneration);
  populationSize=INTEGER_VALUE(RpopulationSize);
  pvalueCutoff=NUMERIC_VALUE(RpValue);
  E_valueCutoff=NUMERIC_VALUE(ReValue);
  extTrim=INTEGER_VALUE(RextTrim);
  minSpaceWidth=INTEGER_VALUE(RminSpaceWidth);
  maxSpaceWidth=INTEGER_VALUE(RmaxSpaceWidth);
  useChIPscore=NUMERIC_VALUE(RuseChIPscore);
  numEM=INTEGER_VALUE(RnumEM);
  fEM=NUMERIC_VALUE(RfEM);
  widthWt=INTEGER_VALUE(RwidthWt);
  fullScan=INTEGER_VALUE(RfullScan);
  slideWinPWM=INTEGER_VALUE(RslideWinPWM);
  numUniq=populationSize;
  stopCriterion=INTEGER_VALUE(RstopCriterion);  
  numBackgSets=INTEGER_VALUE(RnumBackgSets);
  weightType=NUMERIC_VALUE(RweightType);
  //const char *tempRbFileName[1];

 	tempRbFileName = convertRString2Char(RbFileName);	

  //tempRbFileName[0]=CHAR(STRING_ELT(RbFileName,0));
  nmotifs = INTEGER_VALUE(Rnmotifs);
  maskR = INTEGER_VALUE(RmaskR);

  

  if(numSeq>MAX_NUM_SEQ)
  {
    error("Error: maximal number of seqences reached!\nPlease reset MAX_NUM_SEQ in gadem.h and rebuild (see installation)\n");
  }
  
  strcpy(bFileName,tempRbFileName);

  ChIPScore=alloc_double(MAX_NUM_SEQ);
  seqLen=alloc_int(MAX_NUM_SEQ); 
  geneID=alloc_int(MAX_NUM_SEQ);

//  seq=sequences;
  
//  numSeq=size;
  int len; 
  
  for (i=0; i<numSeq; i++)
  {
    len=strlen(seq[i]); 
    seqLen[i]=len;
    geneID[i]=INTEGER(accession)[i];
  }

  aveSeqLen=0; 
  for (i=0; i<numSeq; i++) aveSeqLen +=seqLen[i]; aveSeqLen /=(double)numSeq;
  
  for (i=0; i<numSeq; i++) {
    if (seqLen[i]>maxSeqLen) maxSeqLen=seqLen[i]; 
  }
  
  rseq=alloc_char_char(numSeq,maxSeqLen+1);
  oseq=alloc_char_char(numSeq,maxSeqLen+1);
  orseq=alloc_char_char(numSeq,maxSeqLen+1);
  
  for (i=0; i<numSeq; i++)
  {
    if(seqLen[i]>maxSeqLen) maxSeqLen=seqLen[i]; 
  }
  
  reverse_seq(seq,rseq,numSeq,seqLen);
  
  // make a copy of the original sequences both strands
  for (i=0; i<numSeq; i++)
  {
    for (int j=0; j<seqLen[i]; j++)
    {
      oseq[i][j]=seq[i][j];
      orseq[i][j]=rseq[i][j];
    }
    oseq[i][seqLen[i]]='\0'; orseq[i][seqLen[i]]='\0'; 
  }
    
  if (strcmp(bFileName,"NULL")!= 0)
  {
    bfreq0=alloc_double(5);
    read_background(bFileName,bfreq0);
  }

  if (GET_LENGTH(RListPWM)!= 0)
  {
    startPWMfound=1; 
  }
  else { }
  
    // check for input parameters
  if(numGeneration<1)
  { 
    error("number of generaton < 1.\n");
  }
  if(populationSize<1)
  {
    error("population size < 1.\n");
  }
  if (minSpaceWidth<0)
  { 
    error("minimal number of unspecified bases in spaced dyads <0.\n"); 
  }
  if (maxSpaceWidth<0)
  { 
    error("maximal number of unspecified bases in spaced dyads <0.\n"); 
  }
  if (minSpaceWidth>maxSpaceWidth)
  {
    error("mingap setting must <= to maxgap setting.\n\n"); 
  }
  if (maxSpaceWidth+12>MAX_PWM_LENGTH)
  {
    error("maxgap setting plus word lengths exceed <MAX_PWM_LENGTH>.\n");
  }
  if (numEM<0)
  {
    error("number of EM steps is zero.\n");
  }
  if (numEM==0)
  {
    error("number of EM steps = 0, no EM optimization is carried out.\n");
  }
  
  if (fullScan!=0 && fullScan!=1)
    fullScan=0;
  
  
  maxWordSize=0;
  if (numTop3mer>maxWordSize) maxWordSize=numTop3mer;
  if (numTop4mer>maxWordSize) maxWordSize=numTop4mer;
  if (numTop5mer>maxWordSize) maxWordSize=numTop5mer;
  
    // any one, two or three: tetramer, pentamer, hexamer
  if (numTop3mer==0 && numTop4mer==0 && numTop5mer==0)
  {
    error("maxw3, maxw4, and maxw5 all zero - no words for spaced dyads.\n");
  }
  
  // if (startPWMfound && fEM!=0.5 && fEM!=1.0 & verbose)
  // {
  //   warning("fEM argument is ignored in a seeded analysis\n");
  // }
  
  if (startPWMfound)
  {
    // if(verbose)
    // {
    //   if (populationSize!=10 && populationSize!=100) warning("pop argument is ignored in a seeded analysis, -pop is set to 10.\n");
    //   if (numGeneration!=1 && numGeneration!=5)      warning("gen argument is ignored in a seeded analysis, -gen is set to 1.\n");
    // }
    fEM=1.0;
    populationSize=FIXED_POPULATION; numGeneration=1; 
  }
  
    // number of sequences for EM
  if (fEM>1.0 || fEM<=0.0)
  { 
    error("The fraction of sequences subject to EM is %3.2f.\n",fEM);
  } 
  numSeqEM=(int)(fEM*numSeq);
  


  // memory callocations
  Iseq  =alloc_char(numSeq+1); 
  opwm2 =alloc_double_double(MAX_PWM_LENGTH,4);
  ipwm  =alloc_int_int(MAX_PWM_LENGTH,4);
  logepwm=alloc_double_double(MAX_PWM_LENGTH,4);
  emSeqLen=alloc_int(numSeqEM);
  scoreCutoff=alloc_int(1000);
  // scoreCutoff=alloc_int(populationSize);
  llrDist=alloc_distr(MAX_DIMENSION);
  posWeight=alloc_double_double(numSeq,maxSeqLen);
  sseq=alloc_char_char(MAX_NUM_SEQ,maxSeqLen+1);
  rsseq=alloc_char_char(MAX_NUM_SEQ,maxSeqLen+1);
  bfreq1=base_frequency(numSeq,seq,seqLen);

  if (strcmp(bFileName,"NULL") == 0)
  {
    bfreq0=alloc_double(5);
    for (i=0; i<4; i++)
      {
	bfreq0[i]=bfreq1[i];
      }
  }
  

  // if minN not specified, set the defaults accordingly
  if (minsites==-1) 
  {
    minsites =max(2,(int)(numSeq/20)); 
  }
  minsitesEM=(int)(fEM*minsites);
  
  maxpMutationRate=MAXP_MUTATION_RATE;
  
  // determine the distribution and critical cut point
  pwmDistCutoff=vector_similarity();
  
  /*---------- select a subset of sequences for EM only --------------*/
  if (useChIPscore==1)
  {
    select_high_scoring_seq_for_EM (ChIPScore,numSeq,numSeqEM,Iseq,fEM);
  }
  else
  {
    sample_without_replacement(Iseq,numSeqEM,numSeq);
  }
  /*-------------------- end of selection --------------------------*/
  
  if (maskR==1) mask_repetitive(geneID,seq,numSeq,seqLen,mFileName);

  if (widthWt<20)
  {
    warning("The window width of sequence centered on the nucleotides having large weights in EM for PWM optimization is small\n Motif longer than %d will not be discovered\n",widthWt);
  }
  
  time(&start);
  
    // if (weightType==1 || weightType==3) 
    //ffprintf(output,fp,"window width of sequence centered on the nucleotides having large weights for PWM optimization: %d\n",widthWt);
    //ffprintf(output,fp,"pwm score p-value cutoff for declaring binding site:\t%e\n",pvalueCutoff);
  
  if(verbose)
  {
    ffprintf(output,output,"==============================================================================================\n");
    ffprintf(output,output,"input sequence file:  %s\n",mFileName);
    fprintf(output,"number of sequences and average length:\t\t\t\t%d %5.1f\n",numSeq,aveSeqLen);
    
    fprintf(output,"Use pgf method to approximate llr null distribution\n");
    fprintf(output,"parameters estimated from sequences in:  %s\n\n",mFileName);

    if (weightType!=0) 
      fprintf(output,"non-uniform weight applies to each sequence - type:\t\t%d\n",weightType);
    fprintf(output,"number of GA generations & population size:\t\t\t%d %d\n\n",numGeneration,populationSize);
    fprintf(output,"PWM score p-value cutoff for binding site declaration:\t\t%e\n",pvalueCutoff);
    fprintf(output,"ln(E-value) cutoff for motif declaration:\t\t\t%f\n\n",E_valueCutoff);
//    fprintf(output,"number (percentage) of sequences selected for EM:\t\t%d(%4.1f\%)\n",numSeqEM,100.0*(double)numSeqEM/(double)numSeq);
    fprintf(output,"number of EM steps:\t\t\t\t\t\t%d\n",numEM);
    fprintf(output,"minimal no. sites considered for a motif:\t\t\t%d\n\n",minsites);
    fprintf(output,"[a,c,g,t] frequencies in input data:\t\t\t\t%f %f %f %f\n",bfreq1[0],bfreq1[1],bfreq1[2],bfreq1[3]);
    fprintf(output,"==============================================================================================\n");
  }
  
  // if (pgf) 
  // {
  //   if (userMarkovOrder!=0 & verbose) 
  //   {
  //     warning("The user-specified background Markov order (%d) is ignored when -pgf is set to 1\n",userMarkovOrder);
  //   }
  //   if (bFileName[0]!='\0' & verbose)
  //   {
  //     warning("The user-specified background models: %s are not used when -pgf is set to 1\n",bFileName);
  //   }
  // }
  // if (startPWMfound && fEM!=1.0  & verbose)
  // {
  //   warning("fEM argument is ignored in a seeded analysis\n");
  // }
  
    // determine seq length by counting only [a,c,g,t], seqLen is used in E-value calculation
    // determine the distribution and critical cut point
  pwmDistCutoff=vector_similarity();
  
  if      (weightType==0) assign_weight_uniform(seqLen,numSeq,posWeight);
  else if (weightType==1) assign_weight_triangular(seqLen,numSeq,posWeight);
  else if (weightType==2) assign_weight_normal(seqLen,numSeq,posWeight);
  else
  {
    error("Motif prior probability type not found - please choose: 0, 1, or 2\n");
    // fprintf(output,"Consider: -posWt 1 for strong central enrichment as in ChIP-seq\n");
    // fprintf(output,"          -posWt 0 for others\n\n");
    // exit(0);
  }
  /*    if (startPWMfound) minminSites=minsites;
   else               minminSites=(int)(0.40*minsitesEM);*/
  
  motifCn=0; noMotifFound=0; numCycle=0; numCycleNoMotif=0; 
  int compt=0;
  int lengthList=GET_LENGTH(RListPWM);
 
    /****************************************/ 
    broadcastOnce(maxSeqLen, numEM, startPWMfound, minminSites, maxpFactor, numSeq, numSeqEM, Iseq, bfreq0, posWeight, weightType, pvalueCutoff, emSeqLen, populationSize);
    /****************************************/ 

  do
  {
    if(!startPWMfound)
    {
      
      if(verbose)
      {
        fprintf(output,"*** Running an unseeded analysis ***\n");
        // fprintf(output,"\n|------------------------------------------------------------------|\n");
        // fprintf(output,"|                                                                  |\n");
        // fprintf(output,"|              *** Running an unseeded analysis ***                |\n");
        // fprintf(output,"|                                                                  |\n");
        // fprintf(output,"|------------------------------------------------------------------|\n\n");
      }
      populationSize=INTEGER_VALUE(RpopulationSize);
      numGeneration=INTEGER_VALUE(RnumGeneration);
      dyad  =alloc_chrs(populationSize,4);
      wheel =alloc_wheel(populationSize);
      fitness=alloc_fitness(populationSize);
      maxpFactor=alloc_double(populationSize);
      uniqMotif=alloc_char(populationSize+1);
      opwm  =alloc_double_double_double(populationSize,MAX_PWM_LENGTH,4);
      epwm=alloc_double_double_double(populationSize,MAX_PWM_LENGTH,4);
      pwmConsensus=alloc_char_char(populationSize,MAX_PWM_LENGTH+1);
      pwm   =alloc_double_double_double(populationSize,MAX_PWM_LENGTH,4);
      pwmLen=alloc_int(populationSize);
      sdyad =alloc_char_char(populationSize,MAX_PWM_LENGTH+1);
      word  =alloc_word(numWordGroup,maxWordSize);
      minminSites=(int)(0.40*minsitesEM);

        // identify top-ranked k-mers (k=3,4,5) for spaced dyads
      if(verbose)
        fprintf(output,"GADEM cycle %2d: enumerate and count k-mers... ",numCycle+1);
        
      numWordGroup=word_for_dyad(word,seq,rseq,numSeq,seqLen,bfreq1,&numTop3mer,&numTop4mer,&numTop5mer);
      
      if(verbose)
        fprintf(output,"Done.\n");
      
        // generating a "population" of spaced dyads
      if(verbose)
        fprintf(output,"Initializing GA... ");

      initialisation(dyad,populationSize,numWordGroup,word,minSpaceWidth,maxSpaceWidth,maxpFactor);
      if(verbose)
        fprintf(output,"Done.\n");
      
    }
    else
    {
      if(verbose)
      {
        fprintf(output,"*** Running an seeded analysis ***\n");
        // fprintf(output,"\n|------------------------------------------------------------------|\n");
        // fprintf(output,"|                                                                  |\n");
        // fprintf(output,"|               *** Running a seeded analysis ***                  |\n");
        // fprintf(output,"|                                                                  |\n");
        // fprintf(output,"|------------------------------------------------------------------|\n\n");
      }
      populationSize=FIXED_POPULATION; 
      dyad  =alloc_chrs(populationSize,4);
      pwm=alloc_double_double_double(populationSize,MAX_PWM_LENGTH,4);
      pwmLen=alloc_int(populationSize);
      maxpFactor=alloc_double(populationSize);
      uniqMotif=alloc_char(populationSize+1);
      opwm  =alloc_double_double_double(populationSize,MAX_PWM_LENGTH,4);
      epwm=alloc_double_double_double(populationSize,MAX_PWM_LENGTH,4);
      pwmConsensus=alloc_char_char(populationSize,MAX_PWM_LENGTH+1);
      sdyad =alloc_char_char(populationSize,MAX_PWM_LENGTH+1);
      word  =alloc_word(numWordGroup,maxWordSize);
      wheel =alloc_wheel(populationSize);
      fitness=alloc_fitness(populationSize);
      minminSites=minsites;
      int lengthMatrix;
      
      lengthMatrix=GET_LENGTH(VECTOR_ELT(RListPWM,compt));
      RSpwm=allocMatrix(REALSXP,4,(lengthMatrix/4));
      RSpwm=VECTOR_ELT(RListPWM,compt);
      
      
      pwmLen[0]=read_pwm0(RSpwm,pwm[0],lengthMatrix);
      
      for(i=1; i<populationSize; i++)
      {
        for (int j=0; j<pwmLen[0]; j++)
        {
          for (int k=0; k<4; k++)
          {
            pwm[i][j][k]=pwm[0][j][k];
          }
        }
        pwmLen[i]=pwmLen[0];
      }
      for (i=0; i<populationSize; i++)
      {
        maxpFactor[i]=FIXED_MAXPF*(i+1);
        standardize_pwm(pwm[i],pwmLen[i]);
        consensus_pwm(pwm[i],pwmLen[i],pwmConsensus[i]);
        strcpy(sdyad[i],pwmConsensus[i]);
      }
    }
    generationNoMotif=0;
    
    for (jjj=0; jjj<numGeneration; jjj++)
    {
        // convert spaced dyads to letter probability matrix
      if (!startPWMfound)
      {
        dyad_to_pwm(word,populationSize,dyad,pwm,pwmLen);
      }

    /*
      DO_APPLY(populationCalculation(maxSeqLen, numEM, fitness+ii, 
                                     startPWMfound, minminSites, maxpFactor[ii], 
                                     numSeq, numSeqEM, seq, rseq, seqLen, Iseq, 
                                     bfreq0, posWeight, weightType, 
                                     pvalueCutoff, emSeqLen, 
                                     pwm[ii], pwmLen[ii], epwm[ii], opwm[ii], 
                                     pwmConsensus[ii], scoreCutoff+ii, sdyad[ii], ii),
               populationSize, ii);
    */
      
     /* Create the structure to send to all the other slaves  */ 
      
      broadcastEveryCycle(Iseq, pwm, pwmLen, pwmConsensus, scoreCutoff, sdyad, populationSize);

      populationCalculation(maxSeqLen, numEM, fitness+ii, 
                                     startPWMfound, minminSites, maxpFactor[ii], 
                                     numSeq, numSeqEM, seq, rseq, seqLen, Iseq, 
                                     bfreq0, posWeight, weightType, 
                                     pvalueCutoff, emSeqLen, 
                                     pwm[ii], pwmLen[ii], epwm[ii], opwm[ii], 
                                     pwmConsensus[ii], scoreCutoff+ii, sdyad[ii], ii);

    /* Receive the analyzed data from all the other slaves and compile them */
    //getPopCalcResults(...);


      // for (i=0; i<5; i++)
      // {
      //   fprintf(output,"fitness.value=%lf\n",fitness[i].value);
      //   fprintf(output,"fitness.index=%d\n",fitness[i].index);
      //   fprintf(output,"maxpfactor=%lf\n",maxpFactor[i]);
      //   fprintf(output,"scoreCutoff=%d\n",scoreCutoff[i]);
      //   fprintf(output,"   spacedDyad: %s\n",sdyad[i]);
      //   
      //   for (l=0; l<pwmLen[i]; l++)
      //   {
      //     for (m=0; m<4; m++) 
      //     { 
      //       fprintf(output,"opwm[%d][%d][%d]=%lf ",i,l,m,opwm[i][l][m]);
      //       fprintf(output,"epwm[%d][%d][%d]=%lf ",i,l,m,epwm[i][l][m]);
      //       fprintf(output,"pwm[%d][%d][%d]=%lf ",i,l,m,pwm[i][l][m]);
      //     }
      //     fprintf(output,"\n");
      //   }
      //   fprintf(output,"\n");
      // }
      // 
      // testrand=runif(0,1);
      // fprintf(output,"testrand1=%lf\n",testrand);
      
      if (populationSize>1)
      {
        sort_fitness(fitness,populationSize);
      }



      // for (i=0; i<5; i++)
      // {
      //   fprintf(output,"fitness.value=%lf\n",fitness[i].value);
      //   fprintf(output,"fitness.index=%d\n",fitness[i].index);
      // }
      numUniq=check_pwm_uniqueness_dist(opwm, pwmLen,
                                        populationSize, fitness,
                                        pwmDistCutoff, E_valueCutoff,
                                        uniqMotif, slideWinPWM);


      // for (i=0; i<5; i++)
      // {
      //   fprintf(output,"fitness.value=%lf\n",fitness[i].value);
      //   fprintf(output,"fitness.index=%d\n",fitness[i].index);
      //   fprintf(output,"maxpfactor=%lf\n",maxpFactor[i]);
      //   fprintf(output,"scoreCutoff=%d\n",scoreCutoff[i]);
      //   fprintf(output,"   spacedDyad: %s\n",sdyad[i]);
      //   
      //   for (l=0; l<pwmLen[i]; l++)
      //   {
      //     for (m=0; m<4; m++) 
      //     { 
      //       fprintf(output,"opwm[%d][%d][%d]=%lf",i,l,m,opwm[i][l][m]); 
      //     }
      //     fprintf(output,"\n");
      //   }
      //   fprintf(output,"\n");
      // }
      
      if(verbose)
      {
        fprintf(output,"GADEM cycle[%3d] generation[%3d] number of unique motif: %d\n",numCycle+1,jjj+1,numUniq);
        for (i=0; i<populationSize; i++)
        {
          if (uniqMotif[i]=='1')
          {
            fprintf(output,"   spacedDyad: %s ",sdyad[fitness[i].index]);
            for (int j=strlen(sdyad[fitness[i].index]); j<maxSpaceWidth+10; j++) fprintf(output," ");
            fprintf(output,"motifConsensus: %s ",pwmConsensus[fitness[i].index]);
            for (int j=strlen(sdyad[fitness[i].index]); j<maxSpaceWidth+10; j++) fprintf(output," ");
            fprintf(output," %3.2f fitness: %7.2f\n",maxpFactor[fitness[i].index],fitness[i].value);
          }
        }
        fprintf(output,"\n");
      }


      if (jjj<numGeneration-1)
      {
        // fitness based selection with replacement
        roulett_wheel_fitness(fitness,populationSize,wheel);
        // mutation and crossover operations
        if (populationSize>1)
        {
          testrand=runif(0,1);
          if (testrand>=0.5)
          {
            mutation(dyad,numWordGroup,word,minSpaceWidth,maxSpaceWidth,wheel,populationSize,fitness,uniqMotif,
                      maxpFactor,maxpMutationRate); 
          }
          else
          {
            crossover(dyad,numWordGroup,word,minSpaceWidth,maxSpaceWidth,wheel,populationSize,fitness,uniqMotif, maxpFactor,maxpMutationRate); 
          }
        }
        else
        {
          mutation(dyad,numWordGroup,word,minSpaceWidth,maxSpaceWidth,wheel,populationSize,fitness,uniqMotif, maxpFactor,maxpMutationRate);
        }
      }
    }

    if((numCycle+1)< lengthList)
    {
      compt++;
    }
    else
    {
      startPWMfound=0;
    }
    numCycle++;


    site=alloc_site_site(numUniq+1,MAX_SITES);
    nsites=alloc_int(numUniq+1);
    pwmnewLen=alloc_int(numUniq+1); // after base extension and trimming
    seqCn=alloc_int(MAX_NUM_SEQ);
    bseqCn=alloc_int(MAX_NUM_SEQ);

    // final step user-specified background model is used
    motifCn2=0; // motifCn per GADEM cycle
    for (ii=0; ii<populationSize; ii++) 
    {

      id=fitness[ii].index;
      if(uniqMotif[ii]=='0')
      {
        continue;
      }


      // approximate the exact llr distribution using Staden's method
      // if(verbose)
      // {
      //   fprintf(output,"Approximate the exact pwm llr score distribution using the pgf method.\n");
      // }
      log_ratio_to_int(epwm[id],ipwm,pwmLen[id],bfreq0);

        // compute score distribution of the (int)PWM using Staden's method
      llrDim=pwm_score_dist(ipwm,pwmLen[id],llrDist,bfreq0);

        //fprintf(output,"Avant ScoreCutoff %d \n",scoreCutoff[id]);
      scoreCutoff[id]=determine_cutoff(llrDist,llrDim,pvalueCutoff);
        //fprintf(output,"Apres ScoreCutoff %d \n",scoreCutoff[id]);
        
      if(fullScan)
      {
        nsites[motifCn2]=scan_llr_pgf(llrDist,llrDim,site[motifCn2],numSeq,oseq,orseq,seqLen,ipwm,pwmLen[id],scoreCutoff[id],bfreq0);
      }
      else
      {
        nsites[motifCn2]=scan_llr_pgf(llrDist,llrDim,site[motifCn2],numSeq,seq,rseq,seqLen,ipwm,pwmLen[id],scoreCutoff[id],bfreq0);
      }
      if (nsites[motifCn2]>=max(2,minsites))
      {
      for (int j=0; j<numSeq; j++) seqCn[j]=0;
        for (int j=0; j<nsites[motifCn2]; j++) seqCn[site[motifCn2][j].seq]++;
        
        for (int j=0; j<4; j++) cn[j]=0;
        for (int j=0; j<numSeq; j++)
        {
          if (seqCn[j]==0) cn[0]++;
          if (seqCn[j]==1) cn[1]++;
          if (seqCn[j]==2) cn[2]++;
          if (seqCn[j]>2)  cn[3]++;
        }
        totalSitesInput=nsites[motifCn2];
        if (extTrim)
        {
          if (fullScan)
          {
            extend_alignment(site[motifCn2],numSeq,oseq,orseq,seqLen,nsites[motifCn2],pwmLen[id],&(pwmnewLen[motifCn2]));
          }
          else
          {
            extend_alignment(site[motifCn2],numSeq,seq,rseq,seqLen,nsites[motifCn2],pwmLen[id],&(pwmnewLen[motifCn2]));
          }
        }
        else
        { 
          pwmnewLen[motifCn2]=pwmLen[id];
        } 

        if (fullScan)
        {
          align_sites_count(site[motifCn2],oseq,orseq,nsites[motifCn2],pwmnewLen[motifCn2],opwm2);
        }
        else
        {
          align_sites_count(site[motifCn2],seq,rseq,nsites[motifCn2],pwmnewLen[motifCn2],opwm2);
        }
        standardize_pwm(opwm2,pwmnewLen[motifCn2]);
        logev=E_value(opwm2,nsites[motifCn2],bfreq0,pwmnewLen[motifCn2],numSeq,seqLen);

        if (logev<=E_valueCutoff)
        {
          consensus_pwm(opwm2,pwmnewLen[motifCn2],pwmConsensus[id]);
          if (fullScan)
          {
            SET_VECTOR_ELT(ResultsGadem,increment,print_result_R(site[motifCn2],nsites[motifCn2],numSeq,oseq,orseq,seqLen,logev,opwm2,pwmnewLen[motifCn2],motifCn+1,sdyad[id],pwmConsensus[id],numCycle,pvalueCutoff,maxpFactor[id],geneID));
            increment++;           
            print_motif(site[motifCn2],nsites[motifCn2],oseq,orseq,seqLen,pwmnewLen[motifCn2],motifCn+1,opwm2);
          }
          else
          {
            SET_VECTOR_ELT(ResultsGadem,increment,print_result_R(site[motifCn2],nsites[motifCn2],numSeq,seq,rseq,seqLen,logev,opwm2,pwmnewLen[motifCn2],
                                                                 motifCn+1,sdyad[id],pwmConsensus[id],numCycle,pvalueCutoff,maxpFactor[id],geneID));
            increment++;
            print_motif(site[motifCn2],nsites[motifCn2],seq,rseq,seqLen,pwmnewLen[motifCn2],motifCn+1,opwm2);
          }

          mask_sites(nsites[motifCn2],seq,rseq,seqLen,site[motifCn2],pwmnewLen[motifCn2]);

          /* ----------------------compute the average number of sites in background sequences ----------------------*/
          avebnsites=0; avebnsiteSeq=0;
          for (i=0; i<numBackgSets; i++)
          {
            simulate_background_seq(bfreq0,numSeq,seqLen,sseq);
            reverse_seq(sseq,rsseq,numSeq,seqLen);

            nsites[motifCn2]=scan_llr_pgf(llrDist,llrDim,site[motifCn2],numSeq,sseq,rsseq,seqLen,ipwm,pwmLen[id],scoreCutoff[id],bfreq0);
            
            for (int j=0; j<numSeq; j++) bseqCn[j]=0;
            for (int j=0; j<nsites[motifCn2]; j++) bseqCn[site[motifCn2][j].seq]++;
            
            for (int j=0; j<4; j++) bcn[j]=0;
            for (int j=0; j<numSeq; j++)
            {
              if (bseqCn[j]==0) bcn[0]++;
              if (bseqCn[j]==1) bcn[1]++;
              if (bseqCn[j]==2) bcn[2]++;
              if (bseqCn[j]>2)  bcn[3]++;
            }
              //ffprintf(output,fq,"background set[%2d] Seqs with 0,1,2,>2 sites: %d %d %d %d\n",i+1,bcn[0],bcn[1],bcn[2],bcn[3]);
            avebnsites+=nsites[motifCn2]; avebnsiteSeq+=(numSeq-bcn[0]);
          } 
          avebnsites/=numBackgSets; avebnsiteSeq/=numBackgSets;
          /* -----------------end compute the average number of sites in background sequences ----------------------*/
          motifCn++; motifCn2++; 

			//if((numCycle+1) > lengthList & fixSeeded)
			//	{	
			//	  numCycleNoMotif=1;
			//		startPWMfound=1;
			//		} else {
					numCycleNoMotif=0;
			//	}

        }
      }
    }
    
    /* for (int i=0; i<motifCn2; i++)
    {
      mask_sites(nsites[i],seq,rseq,seqLen,site[i],pwmnewLen[i]); 
    } */
    
    if (site[0])
    { 
      free(site[0]);
      site[0]=NULL;
    }
    if (site)
    {
      free(site);
      site=NULL;
    }
    if (nsites)
    {
      free(nsites);
      nsites=NULL;
    }
    if (pwmnewLen) 
    {
      free(pwmnewLen);
      pwmnewLen=NULL;
    }
    
    if (motifCn2==0)
      numCycleNoMotif++;   
    if (motifCn==nmotifs)
      {
	fprintf(output,"Maximal number of motifs (%d) reached\n",nmotifs);
	break;
      }
    if (numCycleNoMotif==stopCriterion)
      noMotifFound=1;
  }while (!noMotifFound);
  
  
    // fclose(fp);
  /*if (!startPWMfound) {  
   if (dyad[0])      { free(dyad[0]);         dyad[0]=NULL;    }
   if (dyad)         { free(dyad);            dyad=NULL;       }
   }*/
  if (seqLen)
  { 
    free(seqLen);
    seqLen=NULL;
  }
  if (pwm[0][0])       
  {
    free(pwm[0][0]);
    pwm[0][0]=NULL; 
  }
  if (pwm[0])
  { 
    free(pwm[0]);
    pwm[0]=NULL;     
  }
  if (pwm)             
  {
    free(pwm); 
    pwm=NULL;        
  }
  if (opwm2[0])  
  { 
    free(opwm2[0]); 
    opwm2[0]=NULL;
  }
  if (opwm2)     
  {
    free(opwm2); 
    opwm2=NULL;
  }
  if (opwm[0][0])      
  { 
    free(opwm[0][0]);
    opwm[0][0]=NULL;
  }
  if (opwm[0])    
  {
    free(opwm[0]);
    opwm[0]=NULL;
  }
  if (opwm)       
  {
    free(opwm);
    opwm=NULL;
  }
  if(ipwm[0])
  { 
    free(ipwm[0]);     
    ipwm[0]=NULL;  
  }
  if (ipwm)
  {
    free(ipwm);   
    ipwm=NULL;
  }
  if (pwmLen)   
  { 
    free(pwmLen);    
    pwmLen=NULL; 
  }
  if (seq[0])          { free(seq[0]);          seq[0]=NULL;     }
  if (seq)             { free(seq);             seq=NULL;        }
    //  if (rseq[0])         { free(rseq[0]);         rseq[0]=NULL;    }
    // if (rseq)            { free(rseq);            rseq=NULL;       }
    // if (oseq[0])         { free(oseq[0]);         oseq[0]=NULL;    }
    // if (oseq)            { free(oseq);            oseq=NULL;       }
    // if (orseq[0])        { free(orseq[0]);        orseq[0]=NULL;   }
    // if (orseq)           { free(orseq);           orseq=NULL;      }
  if (bfreq1)    
  { 
    free(bfreq1);    
    bfreq1=NULL;  
  }
  if (bfreq0)
  {
    free(bfreq0);
    bfreq0=NULL;
  }

  if (wheel)    
  { 
    free(wheel);    
    wheel=NULL;    
  }
  if (fitness)    
  { 
    free(fitness); 
    fitness=NULL;
  }
  if (mFileName)  
  { 
    free(mFileName);    
    mFileName=NULL; 
  }
  if (oFileName)    
  { 
    free(oFileName);  
    oFileName=NULL;
  }
  if (pwmFileName)    
  {
    free(pwmFileName);
    pwmFileName=NULL;
  }
  if (sdyad[0]) 
  { 
    free(sdyad[0]); 
    sdyad[0]=NULL;
  }
  if (sdyad)    
  {
    free(sdyad);
    sdyad=NULL;
  }
  if (pwmConsensus[0])
  { 
    free(pwmConsensus[0]);
    pwmConsensus[0]=NULL;
  }
  if (pwmConsensus)   
  {
    free(pwmConsensus);
    pwmConsensus=NULL;
  }
  //if (!startPWMfound && word) destroy_word(word,numWordGroup);

  PutRNGstate();
  UNPROTECT(1);
  return(ResultsGadem);
}
Esempio n. 20
0
//retorna um vetor de indivíduos descendentes da população atual
Population nextgeneration()
{
	Population nextgen = &population[POPSIZE];
	Individual *p1,*p2,*ind,*ind2;
	int flag,i,j,r;
	bestindividual = population[0];

	for(i=0;i<NEXTGENSIZE;i+=2)
	{
		//escolha dos pais e crossover
		p1 = selection();
		p2 = selection();
		ind = crossover(p1,p2);
		ind2 = c[1];

		//garantia de variedade genética
		if(evaluate(ind)>=bestindividual->fitness)
		{
			r = rand()%2;
			if(r)
				mutation(ind);
			else
				mutation2(ind);
		}
		if(evaluate(ind2)>=bestindividual->fitness)
		{
			r = rand()%2;
			if(r)
				mutation(ind2);
			else
				mutation2(ind2);
		}
		
		//mutação
		r = rand()%100;
		if(evaluate(ind)>=bestindividual->fitness && r<MUTATIONRATE)
		{
			r = rand()%2;
			if(r)
				mutation(ind);
			else
				mutation2(ind);
			evaluate(ind);
		}
		populationinsert(nextgen,ind,i);

		r = rand()%100;
		if(i+1 < NEXTGENSIZE && evaluate(ind2)>=bestindividual->fitness && r<MUTATIONRATE)
		{
			r = rand()%2;
			if(r)
				mutation(ind2);
			else
				mutation2(ind2);
			evaluate(ind2);
		}
		populationinsert(nextgen,ind2,i+1);
		
	}
	qsort(nextgen,NEXTGENSIZE,sizeof(Individual*),compareind);
	return nextgen;
}
Esempio n. 21
0
ReturnFlag GSTM::run_()
{
	GAPopulation<CodeVInt, GAIndividual<CodeVInt>> subPopul(m_popsize);
	GAIndividual<CodeVInt> ia, ib;
	int i, n;
	double p;
	int flag, flag1;
	double bestlen = DBL_MAX;
	vector<int> arr(m_numDim);

	dynamic_cast<TermMean*>(m_term.get())->initialize(mean());
	while (!ifTerminating())
	{

		/*if(Global::msp_global->mp_problem->getEvaluations()/m_saveFre<m_num){
		mean<<diffEdges()<<" "<<Global::msp_global->mp_problem->getEvaluations()<<endl;
		}*/

#ifdef OFEC_DEMON
		for (i = 0; i<this->getPopSize(); i++)
			updateBestArchive(this->m_pop[i]->self());
		vector<Algorithm*> vp;
		vp.push_back(this);
		msp_buffer->updateBuffer_(&vp);
#endif
		//cout<<Global::msp_global->mp_problem->getEvaluations()<<endl;

		n = 0;
		while (n<m_popsize)
		{
			flag = 0;
			flag1 = 0;
			selection(ia, ib);
			p = Global::msp_global->mp_uniformAlg->Next();
			if (p <= m_PC)
			{
				*subPopul.getPop()[n++] = crossover(ia, ib);
				flag = 1;
			}
			if (flag == 0)
			{
				if (n<m_popsize - 1)
				{
					*subPopul.getPop()[n++] = ia;
					*subPopul.getPop()[n++] = ib;
				}
				else
				{
					*subPopul.getPop()[n++] = ia;
					flag1 = 1;
				}
			}
			p = Global::msp_global->mp_uniformAlg->Next();
			if (p <= m_PM)
			{
				if (flag == 1 || flag1 == 1) mutation(*subPopul.getPop()[n - 1]);
				else
				{
					mutation(*subPopul.getPop()[n - 2]);
					mutation(*subPopul.getPop()[n - 1]);
				}
			}
		}
		for (i = 0; i<m_popsize; i++)
			subPopul.getPop()[i]->evaluate();
		*(static_cast<GAPopulation<CodeVInt, GAIndividual<CodeVInt>>*>(this)) = subPopul;

#ifdef OFEC_CONSOLE
		OptimalEdgeInfo::getOptimalEdgeInfo()->recordEdgeInfo<GAIndividual<CodeVInt>>(Global::msp_global.get(), Solution<CodeVInt>::getBestSolutionSoFar(), m_pop, m_num, m_popsize, m_saveFre);
#endif
		m_iter++;
	}

#ifdef OFEC_CONSOLE
	OptimalEdgeInfo::getOptimalEdgeInfo()->recordEdgeInfo<GAIndividual<CodeVInt>>(Global::msp_global.get(), Solution<CodeVInt>::getBestSolutionSoFar(), m_pop, m_num, m_popsize, m_saveFre, false);
	OptimalEdgeInfo::getOptimalEdgeInfo()->recordLastInfo(Global::msp_global->m_runId, Global::msp_global->mp_problem->getEvaluations());
#endif
	return Return_Terminate;
}
Esempio n. 22
0
void Trainer::breed()
{
    std::sort(agents.begin(), agents.end(), fitness_comparison());
    emit agentsChanged(agents);

    children.clear();

    AgentVector selected_agents = selection();

    AgentVector selected_agents_one;
    AgentVector selected_agents_two;

    for (unsigned int i = 0; i < selected_agents.size(); i++)
    {
        if (i % 2)
            selected_agents_one.push_back(selected_agents[i]);
        else
            selected_agents_two.push_back(selected_agents[i]);
    }

    unsigned int min_size = (selected_agents_one.size() < selected_agents_two.size()) ?
                selected_agents_one.size() : selected_agents_two.size();

    if (min_size != 0)
    {
        Agent *braut = selected_agents.at(0);
        for (unsigned int i = 0; i < min_size; i++)
        {
            Agent *child_one = crossover(*braut, *selected_agents_one[i], rand() % 2);
            Agent *child_two = crossover(*selected_agents_two[i], *selected_agents_one[i], rand() % 2);
//            Agent *child_three = crossover(*selected_agents_one[i], *selected_agents_two[i], rand() % 2);

//            if (child_three)
//                children.push_back(child_three);


            if (child_one && braut != selected_agents_one[i])
            {
                if (rand() % 100 < 10)
                {
                    Genome genome_one = child_one->getGenome();
                    mutate(genome_one);
                    child_one->setGenome(genome_one);
                }

                children.push_back(child_one);
            }

            if (child_two)
            {
                if (rand() % 100 > 80)
                {
                    Genome genome_two = child_two->getGenome();
                    mutate(genome_two);
                    child_two->setGenome(genome_two);
                }

                children.push_back(child_two);
            }

        }

        std::sort(children.begin(), children.end(), fitness_comparison());
        Agent *b = children.at(0);
        b->setName("Brautern");

        emit childrenChanged(children);
    }

    agents.clear();
    agents = children;
}
Esempio n. 23
0
int main(){

	//printf(" *** Real time multiprocessor allocator***\n");

	int i;
	int maxGen = MAXGEN+1;
	int nrGen = 0;			// Number of generations
	ga * ga = (struct ga *) malloc(sizeof(struct ga));
	
	FILE * fitnessFile;
	FILE * chromosomeFile;
	
	remove("chromosome0mut0crossElitism.txt");
	remove("fitness0mut0crossElitism.txt");
	
	fitnessFile = fopen("fitness0mut0crossElitism.txt", "w");
	chromosomeFile = fopen("chromosome0mut0crossElitism.txt", "w");
	
	fprintf(fitnessFile, "%s", "Number of generations, Best Machine, Best fitness, Average fitness \n");
	fprintf(chromosomeFile, "%s", "Machine number, TDF, PHYSICAL CORE id, U, Vcore id, Slice, Period, Pcore\n");
	
	srand(time(NULL));

	//printf("Initializing GA\n");
	initGA(ga);
	//printf("Evaluating fitness\n");
	evaluateFitness(ga);
	fprintf(fitnessFile, "%d, %d, %f, %f\n", nrGen, ga->bestMachineIndex,ga->bestFitness, ga->avgFitness);
	fprintf(chromosomeFile, "%s", "Generation 0\n");
	for (i = 0; i < ga->populationSize; i++) 
	  printChromosome(&(ga->population[i]), chromosomeFile);
	
	
	nrGen++;
	//for (i = 0; i < ga->populationSize; i++) 
	//	printMachineParameters(&(ga->population[i]));

	//while(nrGen < maxGen && ga->bestFitness<1.0 ){
	while(nrGen < maxGen && ga->bestFitness<1.0 ){

		printf("Selection for gen %d ...\n", nrGen);
		selection(ga);
		printf("Mutation for gen %d ...\n", nrGen);
		mutation(ga);
		printf("Crossover for gen %d ...\n", nrGen);
		crossover(ga);
		printf("Evaluating fitness for gen %d ...\n", nrGen);
		evaluateFitness(ga);
		fprintf(fitnessFile, "%d, %d, %f, %f\n", nrGen, ga->bestMachineIndex, ga->bestFitness, ga->avgFitness);
		fprintf(chromosomeFile, "Generation %d", nrGen);		
		for (i = 0; i < ga->populationSize; i++) 
		  printChromosome(&(ga->population[i]), chromosomeFile);
	
	/*	printf("Number of generations %d, ", nrGen);
		printf("Best fitness: %f, ", ga->bestFitness);
		printf("Average fitness: %f \n", ga->avgFitness);

		//for (i = 0; i < ga->populationSize; i++)
		//  printMachineParameters(&(ga->population[i]));
	*/
	
		nrGen++;
			
	} // end while
 
	fclose(chromosomeFile);
	fclose(fitnessFile);
	
        freeGA(ga);
	return 0;

}
Esempio n. 24
0
File: main.cpp Progetto: CCJY/coliru
int main(int argc, char **argv) {
    time_t t;
    /* Intializes random number generator */
   srand((unsigned) time(&t));
	char **population; //include every parent that is about to have childen
	int length = LENGTH;
	int max_population = PSIZE;
	double mutation_rate = MUTAION_RATE;
	int i;
	population = (char **) malloc(max_population * sizeof(char *));
	for (i = 0; i < max_population; i++) {
		population[i] = (char *) malloc(length * sizeof(char));
	}
//	puts("init..");
	initp(population);
//	print_population(population);
	int total_fitness = totalFitness(population);
	printf("total fitness: %d\n", total_fitness);

	double p_crossover = (double) 0.5; //this determines the crossover point in chrom
	int generation = 0;
	int limit = LENGTH * max_population;
	while (total_fitness < limit) {
		generation++;
		for (i = 0; i < max_population; i++) {
			char *child = crossover(population, p_crossover);
			mutate(child, mutation_rate);
			//printf("child: %s\n", child);
			population[i] = child;
		}
		printf("after %d generation\n", generation);
	//	print_population(population);
		total_fitness = totalFitness(population);
		printf("total fitness: %d\n", total_fitness);
	}

	//long long type can represent upto 20 bits of 1 and 0,
	//chroms longer than 20bits will be splited to array of long long numbers

	/*char chrom1[] = "10101010001101011";
	 char chrom2[] = "11010000110010010";
	 int length = sizeof(chrom1)-1;

	 double crossover = (double)0.5; //this determines the crossover point in chrom

	 //generate mask for crossover
	 char *mask1 = (char *) malloc(length*sizeof(char));
	 char *mask2 = (char *) malloc(length*sizeof(char));
	 generate_mask(mask1, mask2, length, crossover);
	 printf("input  1: %15s (%d) 2: %15s (%d) Length: %d\n", chrom1, fitness(chrom1,length), chrom2, fitness(chrom2, length), length);
	 printf("masks  1: %15s 2: %15s\n", mask1, mask2);
	 char *ptr1,*ptr2;

	 //convert the above 4 string values to decimal int following binary rule.
	 long long ret1 = strtoul(chrom1, &ptr1, 2);
	 long long ret2 = strtoul(chrom2, &ptr2, 2);
	 long long m1 = strtoul(mask1, &ptr1, 2);
	 long long m2 = strtoul(mask2, &ptr2, 2);

	 //crossover operation
	 long long ichild1 = (ret1 & m2) ^ (ret2 & m1);
	 long long ichild2 = (ret1 & m1) ^ (ret2 & m2);
	 //convert binary format childern to string, in order to add them to parent pool.
	 char *child1 = (char *)malloc(length * sizeof(char));
	 char *child2 = (char *)malloc(length * sizeof(char));
	 sprintf(child1,"%lld",int_to_binary(ichild1));
	 sprintf(child2,"%lld",int_to_binary(ichild2));

	 printf("child 1: %18s 2: %s",child1,child2);
	 */

	return 0;
}
Esempio n. 25
0
void generation()
{
    individual fuqin1,fuqin2,*pipeiguodu,*pipeichi;
    int *peiduishuzu;//用来存放产生的随机配对
    pipeiguodu=new individual[zhongqunshu1];
    pipeichi=new individual[zhongqunshu1];
    peiduishuzu=new int[zhongqunshu1];
    int member1,member2,j=0,fuzhijishu=0,i=0,temp=0,tt=0;
    float zhizhen;
    //随机遍历的实现
    for(zhizhen=suijibianli();zhizhen<1;(zhizhen=zhizhen+zhizhenjuli))//设定指针1/66
    {
        pipeichi[fuzhijishu]=nowpop[fuzhi(zhizhen)];
        fuzhijishu++;
    }

    //交叉与变异的实现
    //交叉
    for(i=0;i<zhongqunshu1;i++)
    {
        peiduishuzu[i]=-1;
    }
    for (i=0; i<zhongqunshu1; i++)
    { 
        temp =rnd(0,zhongqunshu1-1); //产生值在0-zhongqunshu1-1的随机数 
        while(Exist(temp, i, peiduishuzu))//判断产生的随机数是否已经产生过,如果是,则再产生一个随机数 
        {
            temp =rnd(0,zhongqunshu1-1);
        }
        //如果没有的话,则把产生的随机数放在peiduishuzu中 
        *(peiduishuzu+i) = temp; 
    }
    for(i=0;i<zhongqunshu1-1;i=i+2)
    {
        fuqin1=pipeichi[peiduishuzu[i]];
        fuqin2=pipeichi[peiduishuzu[i+1]];
        crossover(fuqin1,fuqin2,newpop[i],newpop[i+1]);
    }
    for(j=0;j<zhongqunshu1;j++)
    {
        //if(newpop[j].geti<-1000)
        //cout<<"个体数值小于下界了";
        nowpop[j].geti=newpop[j].geti;
    }
    //
    guanjiancanshujisuan();
    //变异的实现
    for(j=0;j<zhongqunshu;j++)
    {
        bianyi(nowpop[j]);
    } 
    //
    guanjiancanshujisuan();
    //精英保留的实现
    jingyingbaoliu();
    //
    guanjiancanshujisuan();
    delete [] peiduishuzu;
    delete [] pipeichi;
    delete [] pipeiguodu;
}
Esempio n. 26
0
    Sequence::SimData neutral_sample( uniform_generator & uni,
				      uniform01_generator & uni01,
				      exponential_generator & expo,
				      poisson_generator & poiss,
				      const double & theta,
				      const double & rho,
				      const int & nsites,
				      const int & nsam,
				      std::vector<chromosome> * sample,
				      arg * sample_history,
				      unsigned * max_chromosomes = NULL,
				      const unsigned & max_chromosomes_inc = 0)
    /*!
      @brief A simple function to generate samples under a neutral equilibrium model.

      A simple function to generate samples under a neutral equilibrium model
      with infinite-sites mutation and a constant recombination rate accross the region.

      \param uni a function/object capable of returning a random double uniformly from [0,k)
      \param uni01 a function/object capable of returning a random probability uniformly from [0,1)
      \param expo a function/object capable of returning an exponentially distributed random variable. 
      The function must take a single double as an argument, which is the mean of the exponential 
      distribution
      \param poiss a function/object capable of returning an poisson distributed random variable. 
      The function must take a single double as an argument, which is the mean of the poisson 
      distribution
      \param theta 4Nu, the coalescent-scaled mutation rate
      \param rho 4Nr, the recombination rate for the whole region
      \param nsites the number of mutational sites to simulate.  Recombination is equally likely
      between any two sites.
      \param nsites the total sample size. (There is no population structure in this routine)
      \param sample A pointer to the sample of chromosomes you wish to simulate.  
      This must be properly initialized, for example using the function init_sample in 
      <Sequence/Coalescent/Initialize.hpp>
      \param sample_history a pointer to the ancestral recombination graph.  This must be
      initialized in the calling enviroment.  In general, you can use init_marginal in 
      <Sequence/Coalescent/Initialize.hpp>
      \param max_chromosomes  This is a pointer to an integer in the calling environment which you
      can use to reserve memory in the array containing the sample of chromosomes.  If the size of \a sample
      ever gets larger than this, max_chromosomes is incremented by \a max_chromosomes_inc
      \param max_chromosomes_inc the amount by which to increment \a max_chromosomes
      \note This function does require a bit of work to use, although not much.  Please see the example
      code that comes with the library, in particular ms--.cc
      \ingroup coalescent
    */
    {
      int NSAM = nsam;

      //this is rho = 4Nr/site
      double littler = rho/(double(nsites-1));

      //a chromosome with nsites sites has nsites-1 positions ("links")
      //at which crossovers can occur, so the total number of
      //links at the start of the simulation is:
      int nlinks = nsam*(nsites-1);
      double t = 0.;
      while(NSAM>1)
	{
	  double rcoal = double(NSAM*(NSAM-1));
	  double rrec = (rho>0.) ? littler*double(nlinks) : 0.;

	  //note--the function calls below scale time in units of 4Ne
	  double tcoal = expo(1./rcoal);
	  double trec = expo(1./rrec);
	  if ( trec < tcoal ) //crossover event
	    {
	      t+=trec;
	      std::pair<int,int> pos_rec = pick_uniform_spot(uni01(),
							     nlinks,
							     sample->begin(),NSAM);
	      assert( pos_rec.second >= 0 );
	      assert( pos_rec.second >= (sample->begin()+pos_rec.first)->first() );
	      assert( pos_rec.second <= ((sample->begin()+pos_rec.first)->last() ) ); 
				       
	      assert( (sample->begin()+pos_rec.first)->links()>0 );
	      nlinks -= crossover(NSAM,pos_rec.first,pos_rec.second,
				  sample,sample_history);
	      NSAM++;
	    }
	  else //common ancestor event
	    {
	      t+=tcoal;
	      std::pair<int,int> two = pick2(uni,NSAM);
	      NSAM -= coalesce(t,nsam,NSAM,two.first,two.second,nsites,
			       &nlinks,sample,sample_history);
	    }
	  if (unsigned(NSAM) < sample->size()/5)
	    {
	      sample->erase(sample->begin()+NSAM+1,sample->end());
	    }
	}
      if (max_chromosomes != NULL && sample->size() > *max_chromosomes)
	*max_chromosomes  += max_chromosomes_inc;

      //As we have scaled time in units of 4Nr generations, we pass theta
      //to the mutation function.  If we had used the following code to
      //generate times:
      //	double tcoal = expo(2./rcoal);
      //	double trec = expo(2./rrec);
      //Then time would be scaled in units of 2Ne generations, 
      //and if our simulation considers theta=4Neu, we'd pass theta/2
      //to the infinite_sites routine

      SimData gametes_obj = infinite_sites_sim_data(poiss,uni,
						    nsites,*sample_history,theta);
      return gametes_obj;
    }
Esempio n. 27
0
int main() {
//	srand(time(0));
//	generateInst(CASE);

	for(CASE = 1; CASE<=10; CASE++) {
		_mkdir("GAgrid");
		strcpy(strdir,"GAgrid//inst");
		itoa(CASE,ch,10);
		strcat(strdir,ch);
		_mkdir(strdir);
		strcat(strdir,"//");
	readInst(CASE);

	int i,j;
	int gen;
	clock_t start;			//////////////////
	avg_result_time = 0;	//////////////////
	for(trialNum = 1; trialNum <= TRIALNUM; trialNum++) {
		strcpy(str,strdir);
		strcat(str,"result.txt");
		ftotal = fopen(str,"a");

		strcpy(str,strdir);
		itoa(trialNum,ch,10);
		strcat(str,"resultMnum");
		strcat(str,ch);
		strcat(str,".txt");
		fresultgMnum = fopen(str,"w");

		strcpy(str,strdir);
		strcat(str,"runtime");
		strcat(str,ch);
		strcat(str,".txt");
		fruntime = fopen(str,"w");

		start = clock();	//////////////////
		gen = 0;
		initialize(CASE);
		evaluate(CASE);
		keep_the_best();
		while(gen < MAXGENS) {
			select();			//using roulette wheel selection
			crossover();
			mutate();
			evaluate(CASE);	
			elitist();						
			gen++;
		//	printf("%d\t%g\t%g\n",gen,pop[POPSIZE].fitness,pop[POPSIZE].cost);
			fprintf(fruntime,"%d\t%g\t%g\n",gen,pop[POPSIZE].fitness,pop[POPSIZE].cost);
		}
		avg_result_time += clock() - start; //////////////////
		printf("%d\t%g\t%g\n",trialNum,pop[POPSIZE].fitness,pop[POPSIZE].cost);
		fprintf(ftotal,"%d\t%g\t%g\t%g\n",trialNum,pop[POPSIZE].fitness,pop[POPSIZE].cost,(double)avg_result_time/trialNum);//////////////////
		for(i=0;i<24;i++) {
			for(j=0;j<MTYPE;j++) {
				fprintf(fresultgMnum,"%d\t",pop[POPSIZE].gMnum[i][j]);
			}
			fprintf(fresultgMnum,"\n");
		}
	//	printf("\n");
		fprintf(fresultgMnum,"\n");
		fclose(fresultgMnum);
		fclose(ftotal);
		fclose(fruntime);
	}
	}

	return 0;
}
Esempio n. 28
0
/* slave 进程 */
void worker()
{
    printf("\tProcessor %d at %s begin work..\n", myid, processor_name);

    MPI_Status status;
    MPI_Request handle;

    int recv_flag = 0;
    int count = 0;
    int upload = 0;

    // 非阻塞接收主进程消息
    MPI_Irecv(selectedGenes, n, MPI_GENETYPE, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &handle);

    while(1)
    {
        // 独立繁衍count代
        count = generations;
        while(count--)
        {
            select();
            crossover();
            mutate();
            evaluate();
            prefer();
            // 若满足终止条件,则向主进程发送最优路径,并结束进程
            if(population[CARDINALITY].fitness <= optimal+margin)
            {
                printf("\tProcessor %d at %s Terminated\n", myid, processor_name);
                MPI_Send(&population[CARDINALITY], 1, MPI_GENETYPE, 0, DONE_TAG, MPI_COMM_WORLD);
                printf("\tProcessor %d at %s exit\n", myid, processor_name);
                return;
            }
            // 探测是否收到主进程的消息
            MPI_Test(&handle, &recv_flag, &status);
            // 若收到主进程的消息
            if(recv_flag)
            {
                printf("\tProcessor %d at %s recv %d\n", myid, processor_name, status.MPI_TAG);

                // 状态重置
                recv_flag = 0;
                // 若接收到DONE_TAG则结束进程
                if(status.MPI_TAG == DONE_TAG)
                {
                    printf("\tProcessor %d at %s exit\n", myid, processor_name);
                    return;
                }
                // 否则,将接收到的优良个体替换种群中最差的个体
                qsort(population, CARDINALITY, sizeof(GeneType), compare);
                for(int i=1; i <= n; i++)
                    assign(&population[CARDINALITY-i], &selectedGenes[i-1]);
                if(selectedGenes[0].fitness < population[CARDINALITY].fitness)
                    assign(&population[CARDINALITY], &selectedGenes[0]);

                // 非阻塞接收主进程消息
                MPI_Irecv(selectedGenes, n, MPI_GENETYPE, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &handle);
            }
        }
        // 繁衍count代后,若没有终止则向主进程发送最优个体
        select_N_best(n);
        MPI_Send(selectedGenes, n, MPI_GENETYPE, 0, PUT_BETTER_TAG, MPI_COMM_WORLD);
        printf("\tProcessor %d at %s upload %d\n", myid, processor_name, upload++);
    }
}
Esempio n. 29
0
	Genotype::Genotype(const ID_type nID, const std::pair<Genotype*, Genotype*> parents) 
		: ID(nID), decision_chromosome(), link_chromosome(),
		  fitness(parents.first->fitness), value(0.0), generator(nID) {
		
		real_type mutation_rate = 0.2, crossover_rate = 0.5;
		int i, j, ii, jj;
		
		//breed new chromosomes from parents, use hardcoded mutation and crossover rates
		fitness->add(ID, this);
		
		//what does crossover rate mean?
		//generate 2 random numbers for decision_chromosome crossover
		std::uniform_int_distribution<> random_int(0, decision_chromosome.size() - 1);
		std::bernoulli_distribution crossover(crossover_rate);
		if( crossover(generator) ) {
			i = random_int(generator);
			
			//take beginning of chromosome from first parent ...
			for(ii=i; ii>=0; --ii) 
				decision_chromosome[ii] = parents.first->decision_chromosome[ii];
			
			//... and the rest from the second parent
			for(ii=decision_chromosome.size()-1; ii>i; --ii) 
				decision_chromosome[ii] = parents.second->decision_chromosome[ii];
		}
		
		//decide whether to mutate
		std::bernoulli_distribution mutate(mutation_rate);
		random_int = std::uniform_int_distribution<>(0, decision_chromosome.size() - 1);
		if( mutate(generator) ) ~decision_chromosome[random_int(generator)]; //flip a bit
		
		//generate 2 random numbers for link_chromosome crossover
		if( crossover(generator) ) {
			ii = random_int(generator);
			
			//take beginning of chromosome from first parent ...
			for(i=i; i>=0; --i) //over genetic nodes
				for(j=link_chromosome[0].size()-1; j>=0; --j) //over each connectivity vector
					link_chromosome[i][j] = parents.first->link_chromosome[i][j];
			
			//... and the rest from the second parent
			for(i=decision_chromosome.size()-1; i>ii; --i) 
				for(j=link_chromosome[0].size()-1; j>=0; --j)
					link_chromosome[i][j] = parents.second->link_chromosome[i][j];
		}
		
		//decide whether to mutate
		//mutations must occur in pairs to preserve K=2 connectivity
		random_int = std::uniform_int_distribution<>(0, link_chromosome.size() - 1);
		i = random_int(generator); //which bitset
		
		random_int = std::uniform_int_distribution<>(0, link_chromosome[0].size() - 1);
		j = random_int(generator); //which false bit to flip
		
		std::bernoulli_distribution random_bit(0.5);
		bool first = random_bit(generator); //which true bit to flip (there are only 2)
		
		ii = link_chromosome[0].size() - 1;
		if( mutate(generator) ) {
			for(ii; ii>=0; --ii) {
				if( link_chromosome[i][ii] ) { //true bit found
					if(first) { link_chromosome[i][ii] = false; break; }
					else first = true; //flip next true bit
				} 
			} 
			
			while(link_chromosome[i][j]) { //make sure bit is false to start with
				j = random_int(generator);
			} 
			//may reflip the same bit, but it doesn't matter; happens rarely
			link_chromosome[i][j] = true;
		} //if
		
	} //constructor
Esempio n. 30
0
int main(int argc, char ** argv)
{
	/*OpenMP*/
	int thread_count = strtol(argv[1],NULL,10);

	struct timeval t_begin,t_end;
	int i;
	int j;
	float elapsed[TESTS_TO_DO];
	float best = 1000000;
	float best_var[VAR];
	float worst = -1;
	float worst_var[VAR];
	float solution;
	int generations;
	population popul;
	for(i=0;i<TESTS_TO_DO;i++)
	{
		ga_init(&popul,VAR);
    
		/* Get time  */
#ifdef __unix__
		gettimeofday(&t_begin, NULL);
#else
		clock_t t = clock();
#endif

		generations = 0;
		while(generations < STOP_GENERATIONS)
		{
			/* Fitness */
			fitness(my_fitness,&popul,thread_count);
        
			/* Crossover  */
			crossover(&popul,thread_count);
 
			generations++;
		}

		/* Get time  */
#ifdef __unix__
		gettimeofday(&t_end, NULL);
		elapsed[i] = ((t_end.tv_sec+t_end.tv_usec/1000000.0)) - \
        (t_begin.tv_sec+t_begin.tv_usec/1000000.0); 
#else
		t = clock() - t;
		elapsed[i] = ((float)t)/CLOCKS_PER_SEC;
#endif   

		/* Apply fitness to sort */
		fitness(my_fitness,&popul,thread_count);

		solution = my_fitness(popul.chromosomes[popul.size-1]);
		if(solution < best)
		{
			best = solution;
			for(j=0;j<VAR;j++)
			{
				best_var[j] = \
				interpret(popul.chromosomes[popul.size-1][j], \
				LIMIT_INFERIOR_X1,LIMIT_SUPERIOR_X1);
			}
		}
		else if (solution > worst)
		{
			worst = solution;
			for(j=0;j<VAR;j++)
			{
				worst_var[j] = \
				interpret(popul.chromosomes[popul.size-1][j], \
				LIMIT_INFERIOR_X1,LIMIT_SUPERIOR_X1);
			}
		}

		/* Free memory allocated */
		ga_end(&popul);
	}	
   
	/* Print results */
	float mean = 0.0;
	for(i=0;i<TESTS_TO_DO;i++)
	{
		printf("Elapsed Time %i: %.6fs\n",i,elapsed[i]);
		mean += elapsed[i];	 
	}
	printf("Elapsed Time - Mean: %f\n\n",(mean/TESTS_TO_DO));

	printf("Worst Result:\t%.8f\n",worst);
	for(j=0;j<VAR;j++)
		printf("x%d: %.8f\n",j,worst_var[j]);

	printf("Best Result:\t%.8f\n",best);
	for(j=0;j<VAR;j++)
		printf("x%d: %.8f\n",j,best_var[j]);

       return 0;
}