lgados.c

An Introduction to Genetic Algorithms for Scientists and Engineers By David Coley, World Scientific

{

  int Individual;
  
  for (Individual=1;Individual<=PopulationSize;Individual++)
    Fitness[Individual] = Unknowns[Individual][1]*Unknowns[Individual][1] + sin(Unknowns[Individual][2]);
}


void FindIntegers()
     /* Decode the strings to sets of decimal integers. */
{
  
  int Individual;
  int bit,StringBit;
  int Unknown;
  
  for (Individual=1;Individual<=PopulationSize;Individual++)
    {
      bit = TotalStringLength + 1;
      
      for (Unknown=NumberOfUnknowns;Unknown>=1;Unknown--)
	{
	  Integers[Individual][Unknown] = 0;
	  
	  for (StringBit=1;StringBit<=SubstringLength;StringBit++)
	    {
	      bit = bit - 1;
	      if (Strings[Individual][bit] == 1)
		Integers[Individual][Unknown] = Integers[Individual][Unknown] + (1 << (StringBit - 1) ) ;
	    }
	}
    }

}

void FindUnknowns()
     /*  Decode the strings to real numbers. */
{

  int Individual;
  int Unknown;

  FindIntegers(); /* First decode the strings to sets of decimal integers. */

  /* Now convert these integers to reals. */
  for (Individual=1;Individual<=PopulationSize;Individual++)
    for (Unknown=1;Unknown<=NumberOfUnknowns;Unknown++)
      Unknowns[Individual][Unknown] = Range[1][Unknown] + Integers[Individual][Unknown] * (Range[2][Unknown] - Range[1][Unknown]) / ( (1 << SubstringLength) - 1);
}

void InitialPopulation()
     /* Create the initial random population.*/
{
  int Individual;
  int bit;

  for (Individual=1;Individual<=PopulationSize;Individual++)
    for (bit=1;bit<=TotalStringLength;bit++)
      if (RND > .5)
	Strings[Individual][bit] = 1;
      else
	Strings[Individual][bit] = 0;
  
  FindUnknowns();  /* Decode strings to real numbers. */
}


void  Mutate()
     /* Visit each bit of each string very occasionally flipping a "1" to a "0" or visa versa. */

{

  int Individual;
  int bit;

  for (Individual=1;Individual<=PopulationSize;Individual++)
    for (bit=1;bit<=TotalStringLength;bit++)
      {
	/* Throw a random number and see if it is less than or equal to the mutation probability.*/
	if (RND <= MutationProbability) /* Mutate. */
	  if (NewStrings[Individual][bit] == 1)
	    NewStrings[Individual][bit] = 0;
	  else
	    NewStrings[Individual][bit] = 1;
      }
}



void  NoCrossover (int Mate1, int Mate2, int NewIndividual)
     /* Pass the selected strings to the temporary population without applying crossover. */
{
  int bit;
  
  for (bit=1;bit<=TotalStringLength;bit++)
    {  
      NewStrings[NewIndividual  ][bit] = Strings[Mate1][bit];
      NewStrings[NewIndividual+1][bit] = Strings[Mate2][bit];
    }
}

void OpenFiles()
     /* Open result files. See Chapter 2 for a description of their contents. */

{
  LGADOSRES=fopen("LGADOS.RES","a");  /* **** Change append. */
  LGADOSALL=fopen("LGADOS.ALL","w");
}

void CloseFiles()
     /* Close results files. */
{
  fclose(LGADOSALL);
  fclose(LGADOSRES);
}

void PrintGeneration(int Generation, double MeanFitness, int FittestIndividual)
     /* Print results to the screen and the files. */
{
  int Individual;
  int bit;
  int Unknown;

  printf("%i, %f, %f\n", Generation, Fitness[FittestIndividual], MeanFitness);  /* Screen. */
  fprintf(LGADOSRES,"%i, %f, %f\n", Generation, Fitness[FittestIndividual], MeanFitness);  

  for (Unknown=1;Unknown<=NumberOfUnknowns;Unknown++)
    {
      printf("%f ",Unknowns[FittestIndividual][Unknown]); /* Screen. */
      fprintf(LGADOSRES,"%f ",Unknowns[FittestIndividual][Unknown]); /* Screen. */
    }
  
  printf("\n");
  fprintf(LGADOSRES,"\n");

  for (Individual=1;Individual<=PopulationSize;Individual++) /****** turn back on. */
    {
      fprintf(LGADOSALL,"%i , %f \n", Generation,Fitness[Individual]); /* File LGADOS.ALL */
      
      for (Unknown=1;Unknown<=NumberOfUnknowns;Unknown++)
	fprintf(LGADOSALL,"%f\n", Unknowns[Individual][Unknown]); /* File LGADOS.ALL */
      
      for (bit = 1;bit<=TotalStringLength;bit++)
	fprintf(LGADOSALL,"%1i",Strings[Individual][bit]); /* File LGADOS.ALL */
      fprintf(LGADOSALL,"\n");
    }
  fprintf(LGADOSALL,"\n");
}


void Replace()
     /*  Replace the old population with the new one. */
{
  int Individual;
  int bit;

  for (Individual=1;Individual<=PopulationSize;Individual++)
    for (bit = 1;bit<=TotalStringLength;bit++)
      Strings[Individual][bit] = NewStrings[Individual][bit];
}

void Scaling (double ScalingConstant, int FittestIndividual, double *SumFitness, double MeanFitness)
     /* Apply Linear Fitness Scaling,
	scaledfitness = a * fitness + b.
	Subject to,
	meanscaledfitness = meanfitness
	and
	bestscaledfitness = c * MaxFitness,
	where c, the scaling constant, is set by the user.

	If the scaling constant is set to zero, or all individuals have the same
	fitness, scaling is not applied.
     */
{

  int Individual;

  double a,b;

  if ( (ScalingConstant != 0.0) && (Fitness[FittestIndividual] - MeanFitness) > 0)
    /* Find a and b. */
    {
      a = (ScalingConstant - 1) * MeanFitness / (Fitness[FittestIndividual] - MeanFitness);
      
      b = (1 - a) * MeanFitness;
      
      /* Adjust the fitness of all members of the population. */
      (*SumFitness) = 0;

      for (Individual=1;Individual<=PopulationSize;Individual++)
	{
	  Fitness[Individual] = a * Fitness[Individual] + b;
	  if (Fitness[Individual] < 0) Fitness[Individual] = 0.0; /* Avoid negative values near the end of a run. */
	  (*SumFitness) = (*SumFitness) + Fitness[Individual]; /*  Adjust the sum of all the fitnesses. */
	}
      /* Adjust the mean of all the fitnesses. */
      MeanFitness = (*SumFitness) / PopulationSize;
    }
}

void Selection (int *mate, double SumFitness, double MeanFitness)
     /* Select a single individual by fitness proportional selection. */
     
{
  double Sum = 0;
  int Individual = 0;

  double RouletteWheel = RND * SumFitness;
  
  do 
    {
      Individual = Individual + 1;
      Sum = Sum + Fitness[Individual];
    }

  while ( (Sum < RouletteWheel) && (Individual != PopulationSize) );
  
  (*mate) = Individual;

}

void Statistics (double * MeanFitness, double * SumFitness, int * FittestIndividual, int Generation)
     /* Calculate the sum of fitness across the population and find the best individual, 
	then apply elitism if required. */

{

  int Individual;

  double MaxFitness = 0;

  (*FittestIndividual) = 0;
  
  for (Individual=1;Individual<=PopulationSize;Individual++)
    {
      if (Fitness[Individual] > MaxFitness)
	{
	  MaxFitness = Fitness[Individual];
	  (*FittestIndividual) = Individual;
	}
      
    }

  if (Elitism == on)  /* Apply elitism. */
    Elite((*SumFitness), FittestIndividual);
  
  (*SumFitness) = 0;  /* Sum the fitness. */
  
  for (Individual=1;Individual<=PopulationSize;Individual++)
    (*SumFitness) += Fitness[Individual];


  /*  Find the average fitness of the population. */
  (*MeanFitness) = (*SumFitness) / (double) PopulationSize;
}