The purpose of this exercise is to get more practice with the basic form of the code for evolutionary algorithms and look at additively separable problems. We will introduce a few more concepts. So this is another warm up. This time we will work with population, crossover, selection, and competition.

The problem

For example: if L=12 and B=3 then fitness(100111101111) is 2 since the string is broken up as: 100 111 101 111 which has 2 blocks of all ones.
If L=32 and B=4 then the maximum fitness is 8.
if L=32 and B=3 then the maximum fitness is 11 with the last block being a 2 bit block.
Note that the gray code idea is irrelvant for this problem.

Here is a possible implementation in C for this fitness function:

int computerFitness(int bits, int blocksize)
{
    unsigned int block;   // a mask for each block
    int fitness;          // fitness accumulator

    fitness = 0; 
    block = (1<<blocksize)-1;
    while (block) { 
        if ((bits&block) == block) fitness++;
        block <<= blocksize;   // shift to next block position
    }

    return fitness;
}

The problem

Write a program named ga that finds the global optimum to the fitness function. The program should take on the command line (not from standard input):

• block size. The size of the blocks of ones that count for fitness.
• the crossover method (either the string "ux" or "2pt")
• crossover probability. The probability that you perform xover
• number of trials. That is the number of times you run the algorithm. This is so that average performance can be printed.
• population size (I guarantee that I will not enter anything but powers of two).
• tournament size

The output of the program will be EXACTLY AS FOLLOWS:

1. two asterisks,
2. your last name, all lower case, that you use to submit your program
3. the number of bits per block
4. the xover method used
5. the xover probability as a decimal number between 0 and 1
6. the number of trials
7. the population size
8. the tournament size
9. the mean number of evaluations until the optimum is found or the limit of the number of evaluations is exceeded,
10. the standard deviation of that number. (HINT: the standard deviation of a sample set can be calculated as:

    sqrt((sum2 - sum*sum/numSamples)/(numSamples-1))

    where sum2 is the sum of the squares of the samples and sum is the sum of the samples. Note this doesn't work if the numSamples == 1 so I guarantee that the number of trials will be >1.

For example the output might be:

** darwin 3 ux .1 100 32 3 3.14159 2.71828

The Experiments

Algorithm Parameters

1/L bit flipping mutation is where each bit has a probability of 1/L of being flipped for an L bit string. If L=32 then this is 1/32. Note: this means that no bits will be flipped with a probability of (31/32)^L. For large L this means (1-1/L)^L --> e^-1 or about a 37% chance of no change. Also more than one bit can be flipped.

Use your program to try at these values:

Num Trials	100
population size:	8 and 64
Xover probabilities	0, .1, .5, .9, 1.0
Xover	ux and 2pt
Block Size	1, 2, 4, 8, 16
Block Size	1, 2, 4, 8, 16
Tournament Size	2, 3, 5

and report your findings in pdf using less than a page using the report.pdf in your tar file. Be sure your name is on your paper. Thanks. I will be looking for any observations you can make about the experiments I proposed and guesses on why you saw the results you saw. Feel free to comment on any other experiments you ran.

Outline of the Steady Algorithms from Class

      initialize P = { X_1, X_2, ... X_n }   // population & initialization
      computeFitness of P 
      while (not goodenough(P)) {                // stopping criteria 
      	  X_i, X_j  = select(P)              // selection
	  if (rand() < xoverProb) {
	  	  X' = xover(X_i, X_j)       // recombination
	  }
	  X' = mutate(X')                    // mutate
	  computeFitness(X')                 // fitness
          insert(P, X')                      // compete
      }

Submission