Class GeneticAlgorithm<T extends Chromosome>
 Type Parameters:
T
 the type ofChromosome
.
In a genetic algorithm, a population of strings (called chromosomes), which encode candidate solutions (called individuals) to an optimization problem, evolves toward better solutions. Traditionally, solutions are represented in binary as strings of 0s and 1s, but other encodings are also possible. The evolution usually starts from a population of randomly generated individuals and happens in generations. In each generation, the fitness of every individual in the population is evaluated, multiple individuals are stochastically selected from the current population (based on their fitness), and modified (recombined and possibly randomly mutated) to form a new population. The new population is then used in the next iteration of the algorithm. Commonly, the algorithm terminates when either a maximum number of generations has been produced, or a satisfactory fitness level has been reached for the population. If the algorithm has terminated due to a maximum number of generations, a satisfactory solution may or may not have been reached.
A typical genetic algorithm requires:
 a genetic representation of the solution domain,
 a fitness function to evaluate the solution domain.
The fitness function is defined over the genetic representation and measures the quality of the represented solution. The fitness function is always problem dependent.
Once we have the genetic representation and the fitness function defined, GA proceeds to initialize a population of solutions randomly, then improve it through repetitive application of selection, crossover and mutation operators.
Here are some basic recommendations of typical parameter values on binary encoding based on empiric studies.
 Crossover Rate
 Crossover rate determines how often will be crossover performed. If there is no crossover, offspring is exact copy of parents. If there is a crossover, offspring is made from parts of parents' chromosome. If crossover rate is 100%, then all offspring is made by crossover. If it is 0%, whole new generation is made from exact copies of chromosomes from old population. However, it this does not mean that the new generation is the same because of mutation. Crossover is made in hope that new chromosomes will have good parts of old chromosomes and maybe the new chromosomes will be better. However it is good to leave some part of population survive to next generation. Crossover rate generally should be high, about 80%  95%. However some results show that for some problems crossover rate about 60% is the best.
 Mutation Rate
 Mutation rate determines how often will be parts of chromosome mutated. If there is no mutation, offspring is taken after crossover (or copy) without any change. If mutation is performed, part of chromosome is changed. Mutation is made to prevent falling GA into local extreme, but it should not occur very often, because then GA will in fact change to random search. Best rates reported are about 0.5%  1%.
 Population Size
 Population size is the number of chromosomes in population (in one generation). If there are too few chromosomes, GA have a few possibilities to perform crossover and only a small part of search space is explored. On the other hand, if there are too many chromosomes, GA slows down. Good population size is about 2030, however sometimes sizes 50100 are reported as best. Some research also shows, that best population size depends on encoding, on size of encoded string.
 Selection
 Tournament selection has become the primary selection technique used for the Genetic Algorithm. Basic roulette wheel selection can be used, but sometimes rank selection can be better. In general, elitism should be used unless other method is used to save the best found solution.
The number of iterations t during each fitness assessment is a knob that adjusts the degree of exploitation in the algorithm. If t is very large, then we're doing more hillclimbing and thus more exploiting; whereas if t is very small, then we're spending more time in the outer algorithm and thus doing more exploring.

Constructor Summary
ConstructorDescriptionGeneticAlgorithm
(T[] seeds) Constructor.GeneticAlgorithm
(T[] seeds, Selection selection, int elitism) Constructor. 
Method Summary
Modifier and TypeMethodDescriptionevolve
(int generation) Performs genetic algorithm for a given number of generations.evolve
(int generation, double threshold) Performs genetic algorithm until the given number of generations is reached or the best fitness is larger than the given threshold.int
Gets the number of iterations of local search in Lamarckian algorithm.T[]
Returns the population of current generation.setLocalSearchSteps
(int t) Sets the number of iterations of local search for Lamarckian algorithm.

Constructor Details

GeneticAlgorithm
Constructor. The default selection strategy is tournament selection of size 3 and probability 0.95. Elitism is also used (the best chromosome is copied to next generation). Parameters:
seeds
 the initial population, which is usually randomly generated.

GeneticAlgorithm
Constructor. By default, elitism is used (the best chromosome is copied to next generation). Parameters:
seeds
 the initial population, which is usually randomly generated.selection
 the selection strategy.elitism
 the number of best chromosomes to copy to new population. When creating new population by crossover and mutation, we have a big chance, that we will lose the best chromosome. Elitism first copies the best chromosome (or a few best chromosomes) to new population. The rest is done in classical way. Elitism can very rapidly increase performance of GA, because it prevents losing the best found solution.


Method Details

population
Returns the population of current generation. Returns:
 the population of current generation.

setLocalSearchSteps
Sets the number of iterations of local search for Lamarckian algorithm. Sets it be zero to disable local search. Parameters:
t
 the number of iterations of local search. Returns:
 this object.

getLocalSearchSteps
public int getLocalSearchSteps()Gets the number of iterations of local search in Lamarckian algorithm. Returns:
 the number of iterations of local search for Lamarckian algorithm.

evolve
Performs genetic algorithm for a given number of generations. Parameters:
generation
 the number of iterations. Returns:
 the best chromosome of last generation in terms of fitness.

evolve
Performs genetic algorithm until the given number of generations is reached or the best fitness is larger than the given threshold. Parameters:
generation
 the maximum number of iterations.threshold
 the fitness threshold. The algorithm stops when a solution is found that satisfies minimum criteria. Returns:
 the best chromosome of last generation in terms of fitness.
