The complete "fitness function" could be more complex, such as applying a linear or exponential scaling of the returned value. It could include aspects the member's history such as a running average or the number of generations without changes to the genome.

There are three primary steps to this reproduction, since we plan to wipe out all members' genomes and replace them with new genomes (new bits) each generation (iteration). The new members for the next iteration will be randomly selected from a pool of the old members, but the selection will be biased towards those most fit members. The steps are:

1. Create a "weighted roulette wheel", an array of values where each of the members is represented in proportion to thier fitness value. More fit members occupy more space in the array. This is done in a quite straight-forward way by populating an array with a number of member numbers, in proportion to thier fitness. This provides the bias towards the most fit.

2. Once the wheel is created a new generation is selected by choosing M random numbers from the weighted wheel.

3. But we won't just make copies when we repopulate the members' genomes. Since the members have been reduced to mere strings of bits, we can apply a "breeding" or "crossover" component. So the potential new members are paired for "mating", and sub-strings are swapped. Two 8-bit strings, for example, might take each others' lower 5 bits resulting in two completely new genomes (array indexes).

Common conditions for stopping are:

GAs begin with a "population" of "members", where each of the members consist of a complete coding of the problem's parameters. In this example, the population is M members consisting of log₂(N) randomly selected bits (which, as an integer, form the index into the array). These N bits are the "genome".

#define MEMBERS 10
#define GENOME_BITS 9
#define ENVIRONMENT_LENGTH 512

int my_community[MEMBERS][GENOME_BITS],
int my_environment[ENVIRONMENT_LENGTH],

Whatever the method is for evaluating the expression for different values of the code (genome), that method is applied here. The particular method for this example is simply returning the value of the array using the genome of each member as an integer index. The returned value is the fitness.

The complete "fitness function" could be more complex, such as applying a linear or exponential scaling of the returned value. It could include aspects the member's history such as a running average or the number of generations without changes to the genome.

...
my_mmbrsInt[membr] = genomeAsInteger(GENOME_BITS, my_community[membr]) ;
fitness[membr]  = my_environment[my_mmbrsInt[membr]] ;
...
fitness[membr] = fitness[membr] - lowest ;
fitness[membr] = fitness_multiplier * fitness[membr] ;
...

The M members have been graded by the fitness function. Some are more "fit" than others. These are the members we are most interested in keeping and will feature in the reproduction (or "breeding" or "mating") process.

There are three primary steps to this reproduction as we plan to wipe out all members' genomes and replace them with genomes (new bits). The new members for the next iteration will be randomly selected from a pool of the old members, but the selection will be biased towards those most fit members. The steps are:

1. Create a "weighted roulette wheel", an array of values where each of the members is represented in proportion to thier fitness value. More fit members occupy more space in the array. This is done in a quite straight-forward way by populating an array with a number of member numbers, in proportion to thier fitness. This provides the bias towards the most fit.

   ww = (int*) (malloc(total_fitness*sizeof(int))) ;
 ...
   for (membr=0;membr<MEMBERS;membr++)
   {
      for (int fit=0;fit<fitness[membr];fit++)
      {
         ww[fitscan] = membr ;
         fitscan++ ;
      }
   }

2. Once the wheel is created a new generation is selected by choosing M random numbers from the weighted wheel.

   for (membr=0;membr<MEMBERS;membr++)
   {
      a_random_num = rand() % total_fitness ; // Choose some point in the total fitness.
      breeding_units[membr] = ww[a_random_num] ;
   }

3. But we won't just make copies when we repopulate the members' genomes. Since the members have been reduced to mere strings of bits, we can apply a "breeding" or "crossover" component. So the potential new members are paired for "mating", and sub-strings are swapped. Two 8-bit strings, for example, might take each others' lower 5 bits resulting in two completely new genomes (array indexes).

   for (membr=0;membr<MEMBERS;membr++)
   {
      // Choose some point to cross/split gene
      //
      a_random_num = rand() % GENOME_BITS ;
      copy_mmbr(my_mmbrsNew[membr],   my_mmbrs[breeding_units[membr]]) ;
      copy_mmbr(my_mmbrsNew[membr+1], my_mmbrs[breeding_units[membr+1]]) ;

      for (int split = 0;split < a_random_num; split++)
      {
         my_mmbrsNew[membr][split]   = my_mmbrs[breeding_units[membr+1]][split] ;
         my_mmbrsNew[membr+1][split] = my_mmbrs[breeding_units[membr]][split] ;
      }
      membr++ ;
   }

There is nothing to see here on the GUI with respect to this part of the GA except for the results. There are no run-time parameters to change the reproduction function.

Sometimes, things go wrong with the whole reproduction business. Occasionally one of the coded parameter values is copied incorrectly. At least we pretend it does. In this example all of those values are bits, so we "flip a bit" to mimic this loss of fidelity.

   int b_random_num ;
   for (membr=0;membr<MEMBERS;membr++)
   {
      if (mutation_probability != 0) {
         a_random_num = rand() % (100-mutation_probability) ;
         if (a_random_num == 0)
         {
            if (my_mutation_bias != 0)
            {
               b_random_num = 1+rand() % total_mutebias ;
               int g = 0 ;
               int acc = mutation_biases[0] ;
               while ((b_random_num > acc) && (g < GENOME_BITS))
               {
                  g++ ;
                  acc += mutation_biases[g] ;
               }
               b_random_num = g ;
            }
            else
            {
               b_random_num = rand() % (GENOME_BITS) ;
            }
            // This "1 if 0, 0 if 1" code could be simpler but it is left
            // as a placeholder (I was considering using the remaining bits
            // of each int for statistics rather than just using an int
            // as only a 1 or 0.
            if (my_mmbrsNew[membr][b_random_num] == 0) {
                my_mmbrsNew[membr][b_random_num] = 1 ;
            } else {
                my_mmbrsNew[membr][b_random_num] = 0 ;
            }
         }
      }
   }

Just like each of the M members in the initial population was evaluated, so too are the new "generation" of members evaluated. As generations go by the population diversity should shrink as the entire population converges towards representing the integer index of array returning the largest value. The decision of when to stop iterating and present a final population is what the "stopping" or "termination criteria" is about. Like other aspects of GAs, it is the subject of much research.

Common conditions for stopping are:

A solution is found that satisfies minimum criteria

Fixed number of generations reached

Allocated budget (computation time/money) reached

The highest ranking solution's fitness is reaching or has reached a plateau such that successive iterations no longer produce better results

Manual inspection

Combinations of the above