GeneticAlgorithm (Jenes)

java.lang.Object
- jenes.GeneticAlgorithm<T>

Type Parameters:
T - The class of chromosomes to work with.

Direct Known Subclasses:

CrowdingGA, IslandGA, KnapsackGA, KnapsackGA, PatternGA, PatternGA, RoyalGA, SimpleGA, SteadyStateGA, TSPGA, TSPGA, TSPGA
```
public class GeneticAlgorithm<T extends Chromosome>
extends java.lang.Object
```
This is the main class of JENES, providing the skeleton for implementing genetic algorithms.
A genetic algorithm can be implemented by providing a Fitness function. An alternative way (but deprecated) is to subclass GeneticAlgorithm and to overwrite the method evaluateIndividual(Individual).
The genetic algorithm body is made of a sequence of stages. Which stages and in which order to consider is left to the algorithm needs. Generally, the sequence is made of a selection operator, followed by a a crossover operator, and then by a mutation operator. This schema is implemented by SimpleGA.
An example of code is provided below. First, the initial population has to be created.
```
 BooleanChromosome chrom = new BooleanChromosome(CHROMOSOME_LENGTH);
 Individual<BooleanChromosome> ind = new Individual<BooleanChromosome>(chrom);
 Population<BooleanChromosome> pop = new Population<BooleanChromosome>(ind,
                POPULATION_SIZE);
 
```
A fitness function is implmented.
```
 Fitness fit = new Fitness(true) {
```
Since:

1.0

Version:

2.2

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`GeneticAlgorithm.ElitismStrategy` The elitism strategy enumeration
`static class`	`GeneticAlgorithm.ResizeStrategy` The resize stategy enumeration.
`static class`	`GeneticAlgorithm.Statistics` This class provides some basic statistics regarding the algorithm execution.

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.List<AlgorithmEventListener<T>>`	`algorithmListeners` The genetic algorithm listeners
`protected Sequence<T>`	`body` The main algorithm sequence
`static int`	`DEFAULT_GENERATION_LIMIT` The default maximum number of generations
`static int`	`DEFAULT_HISTORY_SIZE` The default history size
`protected int`	`elitism` The elitism number
`protected GeneticAlgorithm.ElitismStrategy`	`elitismStrategy` The elitism strategy used by this genetic algorithm
`protected boolean`	`fullEvaluationForced` The flag controlling the evalution.
`protected int`	`generation` Current generation count
`protected int`	`generationLimit` Maximum number of generations
`protected java.util.List<GenerationEventListener<T>>`	`generationListeners` The generation listeners
`protected Population<T>`	`initialPopulation` The initial population
`static int`	`MAX_HISTORY_SIZE` The maximum history size
`static int`	`MIN_HISTORY_SIZE` The minimum history size
`protected Random`	`random` The random instance
`protected double`	`randomization` Rate of randomization of initial population
`protected GeneticAlgorithm.ResizeStrategy`	`resizeStrategy` The resize strategy used by this genetic algorithm
`protected GeneticAlgorithm.Statistics`	`statistics` The statistics object responsible for storing statistics about this genetic algorithm.

Constructor Summary

Constructors
Constructor and Description
`GeneticAlgorithm()` Constructs a new genetic algorithm with no initial population and the default generation limit.
`GeneticAlgorithm(Fitness fitness)` Constructs a new genetic algorithm with no initial population and the default generation limit.
`GeneticAlgorithm(Fitness fitness, Population<T> pop)` Constructs a new genetic algorithm with the specified population and the default generation limit.
`GeneticAlgorithm(Fitness fitness, Population<T> pop, int genlimit)` Constructs a new genetic algorithm with the specified population and the specified generation limit.
`GeneticAlgorithm(Population<T> pop)` Constructs a new genetic algorithm with the specified population and the default generation limit.
`GeneticAlgorithm(Population<T> pop, int genlimit)` Constructs a new genetic algorithm with the specified population and the specified generation limit.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAlgorithmEventListener(AlgorithmEventListener<T> ael)` Adds a new algorthm event listener
`void`	`addGenerationEventListener(GenerationEventListener<T> gel)` Adds a new generation event listener
`void`	`addStage(AbstractStage<T> stage)` Adds a new stage at the genetic algorithm's body
`protected void`	`applyElitism()` Applies the elitism to the current population, according to the chosen strategy.
`protected boolean`	`end()` Provides the algorithm termination condition.
`void`	`evaluateIndividual(Individual<T> individual)` Evaluates a single individual.
`void`	`evaluatePopulation(Population<T> population)` Evaluates the population.
`void`	`evaluatePopulation(Population<T> population, boolean forced)` Evaluates the population.
`void`	`evolve()` Evolves the algorithms by restarting the algorithm from the initial population.
`void`	`evolve(boolean restart)` Evolves the algorithm until the termination condition or the generation limit is reached.
`void`	`evolve(Population<T> pop)` Evolves the algorithms by resetting the initial population and restarting the algorithm.
`Sequence<T>`	`getBody()` Returns the algorithm's body sequence.
`Population<T>`	`getCurrentPopulation()` Deprecated. Use `getLastPopulation()` instead.
`int`	`getElitism()` Returns the number of individuals considered for elitism by the genetic algorithm.
`GeneticAlgorithm.ElitismStrategy`	`getElitismStrategy()` Returns the elitism strategy used by this genetic algorithm
`Fitness`	`getFitness()` Returns the `Fitness` from this genetic algorithm's body
`int`	`getGeneration()` Returns the current generation counter
`int`	`getGenerationLimit()` Returns the generation limit
`Population<T>`	`getHistoryAt(int pos)` Returns the history population at the specified generation.
`int`	`getHistorySize()` Returns the history size that is the number of populations kept by history
`Population<T>`	`getInitialPopulation()` Returns the initial population.
`Population<T>`	`getLastPopulation()` Returns the current population.
`Population<T>`	`getNextPopulation()` Returns the genetic algorithm next population.
`Pool<T>`	`getPool()` Returns the individuals pool used by populations
`double`	`getRandomization()` Provides the randomization rate, that is the percentage of individuals being randomized by the algorithm.
`GeneticAlgorithm.ResizeStrategy`	`getResizeStrategy()` Returns the resize strategy used by this genetic algorithm.
`Runner`	`getRunner()` Get current runner implementation
`GeneticAlgorithm.Statistics`	`getStatistics()` Returns algoritm statistics at the moment of invokation.
`boolean`	`isBiggerBetter()` Deprecated.
`boolean`	`isFitnessChanged()` Says if the fitness is changed or not.
`boolean`	`isFullEvaluationForced()` Returns the current evaluation mode.
`protected void`	`onGeneration(long time)` Invoked when a generation ga end event occurs.
`protected void`	`onInit(long time)` Invoked when an init end ga event occurs.
`protected void`	`onStart(long time)` Invoked when a start ga event occurs.
`protected void`	`onStop(long time)` Invoked when a stop event occurs.
`protected void`	`randomizeIndividual(Individual<T> individual)` Performs an individual randomization.
`protected void`	`randomizePopulation(Population<T> pop)` Perform a population randomization, by itering on individuals.
`void`	`removeAlgorithmEventListener(AlgorithmEventListener ael)` Removes an algorithm event listener
`void`	`removeGenerationEventListener(GenerationEventListener gel)` Removes the generation event listener
`void`	`setBiggerIsBetter(boolean flag)` Deprecated.
`void`	`setElitism(int elitism)` Sets the number of individuals considered for elitism by the genetic algorithm.
`void`	`setElitismStrategy(GeneticAlgorithm.ElitismStrategy es)` Sets the elitism strategy to used by this genetic algorithm.
`void`	`setFitness(Fitness fitness)` Sets the `Fitness`
`void`	`setFullEvaluationForced(boolean flag)` Sets the evalaution mode.
`void`	`setGenerationLimit(int limit)` Sets the generation limit
`void`	`setHistorySize(int hs)` Sets the history size, that is the number of populations kept by history.
`void`	`setRandomization(boolean value)` Sets the randomization rate to 0 or 1, according to the flag.
`void`	`setRandomization(double rate)` Sets the randomization rate.
`void`	`setRandomSeed(long seed)` Impose `Random` seed in order to reproduce an execution producing the same enviroinment
`void`	`setResizeStrategy(GeneticAlgorithm.ResizeStrategy rs)` Sets the resize stragety.
`void`	`setRunner(Runner runner)` Set the `Runner`
`protected void`	`start(boolean reset)` Starts this genetic algorithm.
`protected void`	`stop()` Terminates the genetic algorithm, notifying the stop event to listeners.
`java.lang.String`	`toString()`
`void`	`updateStatistics(GeneticAlgorithm.Statistics stats)` Updates the algoritm statistics at the moment of invokation.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - DEFAULT_GENERATION_LIMIT
```
public static final int DEFAULT_GENERATION_LIMIT
```
    The default maximum number of generations
    
    See Also:
    Constant Field Values
  - DEFAULT_HISTORY_SIZE
```
public static final int DEFAULT_HISTORY_SIZE
```
    The default history size
    
    See Also:
    Constant Field Values
  - MIN_HISTORY_SIZE
```
public static final int MIN_HISTORY_SIZE
```
    The minimum history size
    
    See Also:
    Constant Field Values
  - MAX_HISTORY_SIZE
```
public static final int MAX_HISTORY_SIZE
```
    The maximum history size
    
    See Also:
    Constant Field Values
  - body
```
protected Sequence<T extends Chromosome> body
```
    The main algorithm sequence
  - statistics
```
protected GeneticAlgorithm.Statistics statistics
```
    The statistics object responsible for storing statistics about this genetic algorithm.
  - generation
```
protected int generation
```
    Current generation count
  - randomization
```
protected double randomization
```
    Rate of randomization of initial population
  - generationLimit
```
protected int generationLimit
```
    Maximum number of generations
  - elitism
```
protected int elitism
```
    The elitism number
  - elitismStrategy
```
protected GeneticAlgorithm.ElitismStrategy elitismStrategy
```
    The elitism strategy used by this genetic algorithm
  - initialPopulation
```
protected Population<T extends Chromosome> initialPopulation
```
    The initial population
  - algorithmListeners
```
protected java.util.List<AlgorithmEventListener<T extends Chromosome>> algorithmListeners
```
    The genetic algorithm listeners
  - generationListeners
```
protected java.util.List<GenerationEventListener<T extends Chromosome>> generationListeners
```
    The generation listeners
  - resizeStrategy
```
protected GeneticAlgorithm.ResizeStrategy resizeStrategy
```
    The resize strategy used by this genetic algorithm
  - fullEvaluationForced
```
protected boolean fullEvaluationForced
```
    The flag controlling the evalution. If true, individuals are evaluated in any case.
  - random
```
protected Random random
```
    The random instance
- Constructor Detail
  - GeneticAlgorithm
```
public GeneticAlgorithm()
```
    Constructs a new genetic algorithm with no initial population and the default generation limit.
  - GeneticAlgorithm
```
public GeneticAlgorithm(Population<T> pop)
```
    Constructs a new genetic algorithm with the specified population and the default generation limit.
    
    Parameters:
    pop - the sample population
  - GeneticAlgorithm
```
public GeneticAlgorithm(Population<T> pop,
                int genlimit)
```
    Constructs a new genetic algorithm with the specified population and the specified generation limit.
    
    Parameters:
    pop - the sample population
    genlimit - the generations upper bound
  - GeneticAlgorithm
```
public GeneticAlgorithm(Fitness fitness)
```
    Constructs a new genetic algorithm with no initial population and the default generation limit.
  - GeneticAlgorithm
```
public GeneticAlgorithm(Fitness fitness,
                Population<T> pop)
```
    Constructs a new genetic algorithm with the specified population and the default generation limit.
    
    Parameters:
    pop - the sample population
  - GeneticAlgorithm
```
public GeneticAlgorithm(Fitness fitness,
                Population<T> pop,
                int genlimit)
```
    Constructs a new genetic algorithm with the specified population and the specified generation limit.
    
    Parameters:
    pop - the sample population
    genlimit - the generations upper bound
- Method Detail
  - getFitness
```
public final Fitness getFitness()
```
    Returns the Fitness from this genetic algorithm's body
    
    Returns:
    fitness
  - setFitness
```
public final void setFitness(Fitness fitness)
```
    Sets the Fitness
    
    Parameters:
    fitness - new fitness
  - isFitnessChanged
```
public final boolean isFitnessChanged()
```
    Says if the fitness is changed or not.
    
    Returns:
    true, if fitness is changed
  - getRunner
```
public Runner getRunner()
```
    Get current runner implementation
    
    Returns:
  - setRunner
```
public void setRunner(Runner runner)
```
    Set the Runner
    
    Parameters:
    runner -
  - setRandomSeed
```
public void setRandomSeed(long seed)
```
    Impose Random seed in order to reproduce an execution producing the same enviroinment
    
    Parameters:
    seed - the seed to set
  - getHistorySize
```
public final int getHistorySize()
```
    Returns the history size that is the number of populations kept by history
    
    Returns:
    the history length
  - getPool
```
public final Pool<T> getPool()
```
    Returns the individuals pool used by populations
    
    Returns:
    pool
  - setHistorySize
```
public void setHistorySize(int hs)
```
    Sets the history size, that is the number of populations kept by history.
    
    Parameters:
    hs - the new number of history populations
  - getHistoryAt
```
public final Population<T> getHistoryAt(int pos)
```
    Returns the history population at the specified generation. The pos value can be relative or absolute. If relative, it must be a negative number that specifies how many generations to go back in order to get the population. So that, 0 means the current generation, -1 means one generation back, -2 means two generations back, and so on. If positive, the generation index is absolute. If the population at the specified generation is not available, the method returns null.
    
    Parameters:
    pos - the population position
    
    Returns:
    the history population, if available. Otherwise it returns null.
  - getInitialPopulation
```
public final Population<T> getInitialPopulation()
```
    Returns the initial population. This is the population given as input to the genetic algorithm, thus it is not affected by the initial population randomization.
    
    Returns:
    the initial population
  - getCurrentPopulation
```
public final Population<T> getCurrentPopulation()
```
    Deprecated. Use getLastPopulation() instead.
    
    Returns the current population. This is the current population reference. When the algorithm starts, it is a reference to the initial population. Deprecated. Make use of getLastPopulation() instead.
    
    Returns:
    the current population.
  - getLastPopulation
```
public final Population<T> getLastPopulation()
```
    Returns the current population. This is the population given as input to the algorithm's body at the current generation. When the algorithm starts, it is empty, and it is eventually affected by the randomization process.
    
    Returns:
    the last population processed so far.
  - getNextPopulation
```
public final Population<T> getNextPopulation()
```
    Returns the genetic algorithm next population. This is the population being processed by the algorithm's body at the current generation. It is the population that will be given as input to the algorithm's body sequence at the following generation.
    
    Returns:
    the next population
  - evolve
```
public final void evolve()
                  throws AlgorithmException
```
    Evolves the algorithms by restarting the algorithm from the initial population.
    
    Throws:
    
    AlgorithmException
  - evolve
```
public final void evolve(Population<T> pop)
```
    Evolves the algorithms by resetting the initial population and restarting the algorithm.
    
    Throws:
    
    AlgorithmException
  - evolve
```
public final void evolve(boolean restart)
                  throws AlgorithmException
```
    Evolves the algorithm until the termination condition or the generation limit is reached. Depending on the argument, the algorithm restarts or continues from the last population.
    
    Parameters:
    restart - if true, the initial population is reset; if false, the algorithm continues from the last population.
    
    Throws:
    
    AlgorithmException
  - end
```
protected boolean end()
```
    Provides the algorithm termination condition. By default it returns false as reaching the generation limit is the sole ending criterion Subclasses can override this method in order to provide a problem specific termination condition.
    
    Returns:
    true if the ga evolution reached the termination condition, false otherwise
  - start
```
protected final void start(boolean reset)
```
    Starts this genetic algorithm. This method performs the algorithm initialization and notifies the start and init events. It is automatically invoked by the method evolve(), thus it should not be explicity invoked.
    
    Parameters:
    reset - if true, the algorithm reset the initial population.
  - stop
```
protected final void stop()
```
    Terminates the genetic algorithm, notifying the stop event to listeners. It is automatically invoked by the method evolve(), thus it should not be explicity invoked.
  - onStart
```
protected void onStart(long time)
```
    Invoked when a start ga event occurs. By default, no action is performed. Override this method to make the GeneticAlgorithm subclass able to be notfied of the start event.
    
    Parameters:
    time - the start event time expressed in milliseconds
  - onInit
```
protected void onInit(long time)
```
    Invoked when an init end ga event occurs. By default, no action is performed. Override this method to make the GeneticAlgorithm subclass able to be notfied of the init event.
    
    Parameters:
    time - the init event time expressed in milliseconds
  - onStop
```
protected void onStop(long time)
```
    Invoked when a stop event occurs. By default, no action is performed. Override this method to make the GeneticAlgorithm subclass able to be notfied of the stop event.
    
    Parameters:
    time - the stop event time expressed in milliseconds
  - onGeneration
```
protected void onGeneration(long time)
```
    Invoked when a generation ga end event occurs. By default, no action is performed. Override this method to make the GeneticAlgorithm subclass able to be notfied of the generation event.
    
    Parameters:
    time - the generation event time expressed in milliseconds
  - evaluatePopulation
```
public final void evaluatePopulation(Population<T> population)
```
    Evaluates the population. The method iterates the evaluation on each individual. Evalution is performed according to fullEvaluationForced
    
    Parameters:
    population - the population to be evaluated
  - evaluatePopulation
```
public final void evaluatePopulation(Population<T> population,
                      boolean forced)
```
    Evaluates the population. The method iterates the evaluation on each individual. Evalution is performed according to flag
    
    Parameters:
    population - the population to be evaluated
  - evaluateIndividual
```
public void evaluateIndividual(Individual<T> individual)
```
    Evaluates a single individual. This evaluation of individuals is specifically related to the problem to solve. If the genetic algorithm's body has a Fitness, this method calls Fitness.evaluate(jenes.population.Individual) method, otherwise method requiring an implementation by the sublass.
    
    Parameters:
    individual - the individual to be evaluated
  - randomizePopulation
```
protected final void randomizePopulation(Population<T> pop)
```
    Perform a population randomization, by itering on individuals. This process is generally useful to enrich the population diversity, necessary to the genetic algorithm for exploiting the search space, especially the initial population is created by cloning a sample individual.
    The percentage of individuals to be randomized can be finely controlled by the randomization rate. This is useful in many problems where a dominant solution should be kept in the population, but still providing a random genetic variety. The randomization rate is controlled by the setRandomization(double) method.
    This method is automatically invoked by the start(boolean) method, so no explicit invokation is required.
    
    Parameters:
    pop - the population to randomize
  - randomizeIndividual
```
protected void randomizeIndividual(Individual<T> individual)
```
    Performs an individual randomization. It is invoked by randomizePopulation(Population). By default randomization is delegated to the individual. In some problems, it would be useful to control the randomization process of individual. This is especially the case of when there are some constraints on genes in order to make the individual valid.
    
    Parameters:
    individual - the individual to be randomize
  - setRandomization
```
public final void setRandomization(boolean value)
```
    Sets the randomization rate to 0 or 1, according to the flag. By this method is possible to apply the randomization process to the whole population or not at all.
    
    Parameters:
    value - if true the rate is set to 1, otherwise to 0.
  - setRandomization
```
public void setRandomization(double rate)
```
    Sets the randomization rate. The randomization rate represents the percentage of individuals that will be randomized. The value should be within [0,1]. However the method automatically trims values outside the unary range, so that negative values are trimmed to 0 and values bigger than 1, are trimmed to 1. Therefore the method is consistent for any value.
    
    Parameters:
    rate - the randomization rate to use during the randomization phase
  - getRandomization
```
public final double getRandomization()
```
    Provides the randomization rate, that is the percentage of individuals being randomized by the algorithm.
    
    Returns:
    the randomization rate.
  - getGeneration
```
public final int getGeneration()
```
    Returns the current generation counter
    
    Returns:
    the current generation counter
  - getGenerationLimit
```
public final int getGenerationLimit()
```
    Returns the generation limit
    
    Returns:
    the maximum number of generations
  - setGenerationLimit
```
public void setGenerationLimit(int limit)
```
    Sets the generation limit
    
    Parameters:
    limit - the new generation limit
  - addStage
```
public void addStage(AbstractStage<T> stage)
```
    Adds a new stage at the genetic algorithm's body
    
    Parameters:
    stage - the stage to be add
  - isBiggerBetter
```
@Deprecated
public final boolean isBiggerBetter()
```
    Deprecated.
    
    Says if the algorithm's body objective is set to maximize or minimize individual fitness.
    
    Returns:
    true is the body objective is to maximize the fitness false otherwise
  - setBiggerIsBetter
```
@Deprecated
public void setBiggerIsBetter(boolean flag)
```
    Deprecated.
    
    Sets the algorithm's body objective to maximize (true) or minimize (false) the individual fitness. All stages belonging to the body sequence are recursevely set according to the flag.
    
    Parameters:
    flag - true to set the body to maximize the fitness, false to minimize
  - isFullEvaluationForced
```
public boolean isFullEvaluationForced()
```
    Returns the current evaluation mode. By defualt it is false.
    
    Returns:
    true, if evaluation is referred to the whole popuation.
  - setFullEvaluationForced
```
public void setFullEvaluationForced(boolean flag)
```
    Sets the evalaution mode.
    
    Parameters:
    flag - - true if evaluation is referred to the whole popuation. False if evaluation is only referred to unevaluated individuals. By default it is false.
  - applyElitism
```
protected final void applyElitism()
```
    Applies the elitism to the current population, according to the chosen strategy. This method is authomatically invoked by evolve(), and should not be explicitaly invoked.
  - getElitism
```
public final int getElitism()
```
    Returns the number of individuals considered for elitism by the genetic algorithm.
    
    Returns:
    the elitism parameter
  - setElitism
```
public void setElitism(int elitism)
```
    Sets the number of individuals considered for elitism by the genetic algorithm. If it is 0, elitism has no place in this algorithm.
    
    Parameters:
    elitism - the new elitism parameter
  - getElitismStrategy
```
public final GeneticAlgorithm.ElitismStrategy getElitismStrategy()
```
    Returns the elitism strategy used by this genetic algorithm
    
    Returns:
    the elitism strategy
  - setElitismStrategy
```
public void setElitismStrategy(GeneticAlgorithm.ElitismStrategy es)
```
    Sets the elitism strategy to used by this genetic algorithm. This stratehy can be RANDOM or WORST: in the first case the random individuals will be replaced by the elite individuals; in the latter the algorithm will replace the worst individuals.
    
    Parameters:
    es - the elitism strategy
  - setResizeStrategy
```
public void setResizeStrategy(GeneticAlgorithm.ResizeStrategy rs)
```
    Sets the resize stragety. This is for advanced use. The genetic algorithm should have a need to resize an existing population, in particular to expand it. Expanding the population would eventually require to create new Individual. The resize strategy specifies the way to perform such a task. Possible strategies are:
    - GeneticAlgorithm.ResizeStrategy.AUTO: entails the creation of new individuals, generally by cloning.
    - GeneticAlgorithm.ResizeStrategy.EMPTY: expands the population, without creating new individuals.
    - GeneticAlgorithm.ResizeStrategy.NONE: disables the automatic resize of populations.
    Parameters:
    rs - the new resize strategy
  - getResizeStrategy
```
public final GeneticAlgorithm.ResizeStrategy getResizeStrategy()
```
    Returns the resize strategy used by this genetic algorithm.
    
    Returns:
    the resize strategy
  - getBody
```
public final Sequence<T> getBody()
```
    Returns the algorithm's body sequence.
    
    Returns:
    the body stage sequence
  - addAlgorithmEventListener
```
public final void addAlgorithmEventListener(AlgorithmEventListener<T> ael)
```
    Adds a new algorthm event listener
    
    Parameters:
    ael - the listener to add
  - removeAlgorithmEventListener
```
public final void removeAlgorithmEventListener(AlgorithmEventListener ael)
```
    Removes an algorithm event listener
    
    Parameters:
    ael - the listener to remove
  - addGenerationEventListener
```
public final void addGenerationEventListener(GenerationEventListener<T> gel)
```
    Adds a new generation event listener
    
    Parameters:
    gel - the generation listener to add
  - removeGenerationEventListener
```
public final void removeGenerationEventListener(GenerationEventListener gel)
```
    Removes the generation event listener
    
    Parameters:
    gel - the listener to remove
  - getStatistics
```
public final GeneticAlgorithm.Statistics getStatistics()
```
    Returns algoritm statistics at the moment of invokation.
    
    Returns:
    an object containing the algorithm statistics
  - updateStatistics
```
public final void updateStatistics(GeneticAlgorithm.Statistics stats)
```
    Updates the algoritm statistics at the moment of invokation.
    
    Parameters:
    stats - the statistics object to be updated
  - toString
```
public final java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class GeneticAlgorithm<T extends Chromosome>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_GENERATION_LIMIT

DEFAULT_HISTORY_SIZE

MIN_HISTORY_SIZE

MAX_HISTORY_SIZE

body

statistics

generation

randomization

generationLimit

elitism

elitismStrategy

initialPopulation

algorithmListeners

generationListeners

resizeStrategy

fullEvaluationForced

random

Constructor Detail

GeneticAlgorithm

GeneticAlgorithm

GeneticAlgorithm

GeneticAlgorithm

GeneticAlgorithm

GeneticAlgorithm

Method Detail

getFitness

setFitness

isFitnessChanged

getRunner

setRunner

setRandomSeed

getHistorySize

getPool

setHistorySize

getHistoryAt

getInitialPopulation

getCurrentPopulation

getLastPopulation

getNextPopulation

evolve

evolve

evolve

end

start

stop

onStart

onInit

onStop

onGeneration

evaluatePopulation

evaluatePopulation

evaluateIndividual

randomizePopulation

randomizeIndividual

setRandomization

setRandomization

getRandomization

getGeneration

getGenerationLimit

setGenerationLimit

addStage

isBiggerBetter

setBiggerIsBetter

isFullEvaluationForced

setFullEvaluationForced

applyElitism

getElitism

setElitism

getElitismStrategy

setElitismStrategy

setResizeStrategy

getResizeStrategy

getBody