GeneticAlgorithm.cpp

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/*   G E N E T I C   A L G O R I T H M   C L A S S                            */
/*                                                                            */
/*   Roberto Lopez                                                            */
/*   International Center for Numerical Methods in Engineering (CIMNE)        */
/*   Technical University of Catalonia (UPC)                                  */
/*   Barcelona, Spain                                                         */
/*   E-mail: rlopez@cimne.upc.edu                                             */
/*                                                                            */
/******************************************************************************/

#include <iostream>
#include <fstream>
#include <algorithm>
#include <functional>
#include <math.h>
#include <time.h>

#include "GeneticAlgorithm.h"

namespace Purple
{

// GENERAL CONSTRUCTOR 
//
/// General constructor. It creates a genetic training
/// algorithm object associated to a performance functional object. 
/// It also initializes the class members to their default values:
///
/// Training operators:
/// <ul>
/// <li> Fitness assignment method: Linear ranking.
/// <li> Selection method: Stochastic universal sampling.
/// <li> Recombination method: Intermediate.
/// <li> Mutation method: Normal.
/// </ul>
///
/// Training parameters:
/// <ul>
/// <li> Population size: 10 * [number of free parameters].
/// <li> Selective pressure: 1.5.
/// <li> Recombination size: 0.25.
/// <li> Mutation rate: = 1.0 / [number of free parameters].
/// <li> Mutation range: = 0.1
/// </ul>
///
/// Stopping criteria:
/// <ul> 
/// <li> Performance goal: 0.0.
/// <li> Maximum training time: 1.0e6.
/// <li> Maximum number of iterations: 100.
/// </ul> 
///  
/// User stuff: 
/// <ul>
/// <li> Iterations between showing progress: 1.
/// </ul>
///
/// @param newPerformanceFunctional: Pointer to a performance functional object.

GeneticAlgorithm::GeneticAlgorithm(ObjectiveFunction* newObjectiveFunction)
: OptimizationAlgorithm(newObjectiveFunction)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   // Fitness assignment method

   fitnessAssignmentMethod = LinearRanking;

   // Selection method

   selectionMethod = StochasticUniversalSampling;

   // Recombination method

   recombinationMethod = Intermediate;

   // Mutation method

   mutationMethod = Normal;

   // Training parameters

   populationSize = 10*numberOfVariables;

   selectivePressure = 1.5;

   recombinationSize = 0.25;

   mutationRate = 1.0/numberOfVariables;
   mutationRange = 0.1;

   // Stopping criteria

   evaluationGoal = 0.0;
   maximumTime = 1.0e12;

   maximumNumberOfGenerations = 100;

   showPeriod = 1;

   // Population matrix

   Matrix<double> newPopulation(populationSize, numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      for(int j = 0; j < numberOfVariables; j++)
      {
         double random = (double)rand()/(RAND_MAX+1.0);

         newPopulation[i][j] = -1.0 + 2.0*random;
      }
   }

   population = newPopulation;

   // Performance vector

   Vector<double> newEvaluation(populationSize, 0.0);

   evaluation = newEvaluation;

   // Fitness vector

   Vector<double> newFitness(populationSize, 0.0);

   fitness = newFitness;

   // Selection vector

   Vector<bool> newSelection(populationSize, false);

   selection = newSelection;

}


// DEFAULT CONSTRUCTOR
//
/// Default constructor. It creates a genetic training algorithm object
/// not associated to any performance functional object. 
/// It also initializes the class members to their default values:
///
/// Training operators:
/// <ul>
/// <li> Fitness assignment method: Linear ranking.
/// <li> Selection method: Stochastic universal sampling.
/// <li> Recombination method: Intermediate.
/// <li> Mutation method: Normal.
/// </ul>
///
/// Training parameters:
/// <ul>
/// <li> Population size: 0.
/// <li> Selective pressure: 1.5.
/// <li> Recombination size: 0.25.
/// <li> Mutation rate: = 0.1.
/// <li> Mutation range: = 0.1
/// </ul>
///
/// Stopping criteria:
/// <ul> 
/// <li> Performance goal: 0.0.
/// <li> Maximum training time: 1.0e6.
/// <li> Maximum number of iterations: 100.
/// </ul> 
///  
/// User stuff: 
/// <ul>
/// <li> Iterations between showing progress: 1.
/// </ul>

GeneticAlgorithm::GeneticAlgorithm(void) : OptimizationAlgorithm()
{
   // Fitness assignment method

   fitnessAssignmentMethod = LinearRanking;

   // Selection method

   selectionMethod = StochasticUniversalSampling;

   // Recombination method

   recombinationMethod = Intermediate;

   // Mutation method

   mutationMethod = Normal;

   // Training parameters

   populationSize = 0;

   selectivePressure = 1.5;

   recombinationSize = 0.25;

   mutationRate = 0.1;
   mutationRange = 0.1;

   // Stopping criteria

   evaluationGoal = 0.0;
   maximumTime = 1.0e12;

   maximumNumberOfGenerations = 100;

   showPeriod = 1;

}

// DESTRUCTOR

/// Destructor.

GeneticAlgorithm::~GeneticAlgorithm(void)
{

}


// METHODS

// int getPopulationSize(void) method

/// This method returns the number of individuals in the population.

int GeneticAlgorithm::getPopulationSize(void)
{
   return(populationSize);
}


// void setMaximumNumberOfGenerations(int) method

void GeneticAlgorithm
::setMaximumNumberOfGenerations(int newMaximumNumberOfGenerations)
{
   if(newMaximumNumberOfGenerations <= 0)
   {
      std::cout << std::endl
                << "Error: void setMaximumNumberOfGenerations(int) method."
                << std::endl
                << "Maximum number of generations must be greater than 0."
                << std::endl << std::endl;

      exit(1);
   }
   else
   {
      maximumNumberOfGenerations = newMaximumNumberOfGenerations;
   }
}

// void setIterationsBetweenShowingProgress(int) method

/// This method sets a new number of iterations between the optimization
/// showing progress.
///
/// @param newIterationsBetweenShowingProgress:
/// Number of iterations between the optimization showing progress.
///
/// @see getOptimal(void).

void GeneticAlgorithm::setShowPeriod(int newShowPeriod)
{
   if(newShowPeriod <= 0)
   {
      std::cout << std::endl
                << "Error: void setShowPeriod(int) method."
                << std::endl
                << "Show period must be greater than 0."
                << std::endl << std::endl;

      exit(1);
   }
   else
   {
      showPeriod = newShowPeriod;
   }
}


// Vector<double> getMeanPerformanceTrainingHistory(void) method

/// This method returns a history with the mean performance of the population during training. 
///
/// @see getBestPerformanceTrainingHistory(void).
/// @see getStandardDeviationOfPerformanceTrainingHistory(void).

Vector<double> GeneticAlgorithm::getMeanEvaluationHistory(void)
{
   return(meanEvaluationHistory);
}


// Vector<double> getStandardDeviationOfPerformanceTrainingHistory(void) method

/// This method returns a history with the standard deviation of the population performance 
/// during training. 
///
/// @see getBestPerformanceTrainingHistory(void).
/// @see getMeanPerformanceTrainingHistory(void).

Vector<double> GeneticAlgorithm::getStandardDeviationEvaluationHistory(void)
{
   return(standardDeviationEvaluationHistory);
}


// Vector<double> getBestPerformanceTrainingHistory(void) method

/// This method returns a history with the performance of the best individual ever during training. 
///
/// @see getMeanPerformanceTrainingHistory(void).
/// @see getStandardDeviationOfPerformanceTrainingHistory(void).

Vector<double> GeneticAlgorithm::getBestEvaluationHistory(void)
{
   return(bestEvaluationHistory);
}


// void setPopulationSize(int) method
//
/// This method sets a new population with a new number of individuals.  
/// The new population size must be an even number equal or greater than four. 
///
/// @param newPopulationSize: Number of individuals in the population.
/// This must be an even number equal or greater than four. 

void GeneticAlgorithm::setPopulationSize(int newPopulationSize)
{
   if(newPopulationSize < 4)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. "
                << "void setPopulationSize(int) method." << std::endl
                << "New population size must be equal or greater than 4."
                << std::endl << std::endl;

      exit(1);
   }
   else if(newPopulationSize%2 != 0)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. "
                << "void setPopulationSize(int) method." << std::endl
                << "New population size is not divisible by 2." << std::endl
                << std::endl;

      exit(1);
   }


   populationSize = newPopulationSize;

   // Set population matrix

   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Matrix<double> newPopulation(populationSize, numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      for(int j = 0; j < numberOfVariables; j++)
      {
         double random = (double)rand()/(RAND_MAX+1.0);

         newPopulation[i][j] = -1.0 + 2.0*random;
      }
   }


   population = newPopulation;

   // Set evaluation vector

   Vector<double> newEvaluation(populationSize, 0.0);

   evaluation = newEvaluation;

   // Set fitness vector

   Vector<double> newFitness(populationSize, 0.0);

   fitness = newFitness;

   // Set selection vector

   Vector<bool> newSelection(populationSize, false);

   selection = newSelection;
}


// Population stuff

// Matrix<double> getPopulation(void) method

/// This method returns the population Matrix.

Matrix<double> GeneticAlgorithm::getPopulation(void)
{
   return(population);
}


// Vector<double> getPerformance(void) method

/// This method returns the actual performance value of all individuals in the population.
///
/// @see getFitness(void).
/// @see getSelection(void).

Vector<double> GeneticAlgorithm::getEvaluation(void)
{
   return(evaluation);
}


// Vector<double> getFitness(void) method

/// This method returns the actual fitness value of all individuals in the population.
///
/// @see getPerformance(void).
/// @see getSelection(void).

Vector<double> GeneticAlgorithm::getFitness(void)
{
   return(fitness);
}


// Vector<bool> getSelection(void) method

/// This method returns the actual selection value of all individuals in the population.
///
/// @see getPerformance(void).
/// @see getFitness(void).

Vector<bool> GeneticAlgorithm::getSelection(void)
{
   return(selection);
}


// void setPopulation(Matrix<double>) method

/// This method sets a new population.
///
/// @param newPopulation: Population Matrix.

void GeneticAlgorithm::setPopulation(Matrix<double> newPopulation)
{

   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   if(newPopulation.getNumberOfRows() != populationSize)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. "
                << "void setPopulation(Matrix<double>) method." << std::endl
                << "New population size is not equal to population size."
                << std::endl << std::endl;

      exit(1);
   }
   else if(newPopulation.getNumberOfColumns() != numberOfVariables)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. "
                << "void setPopulation(Matrix<double>) method." << std::endl
                << "New number of free parameters is not equal to "
                << "number of free parameters." << std::endl
                << std::endl;

      exit(1);
   }

   population = newPopulation;
}


// void setPerformance(Vector<double>) method

/// This method sets a new population performance Vector.
///
/// @param newPerformance: Population performance values.

void GeneticAlgorithm::setEvaluation(Vector<double> newEvaluation)
{
   if(newEvaluation.getSize() != populationSize)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. "
                << "void setEvaluation(Vector<double>) method." << std::endl
                << "Size is not equal to population size." << std::endl;

      exit(1);
   }

   evaluation = newEvaluation;
}


// void setFitness(Vector<double>) method

/// This method sets a new population fitness Vector.
///
/// @param newFitness: Population fitness values.

void GeneticAlgorithm::setFitness(Vector<double> newFitness)
{
   if(newFitness.getSize() != populationSize)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void setFitness(Vector<double>) method." << std::endl
                << "Size is not equal to population size." << std::endl;

      exit(1);
   }
   else
   {
      fitness = newFitness;
   }
}


// void setSelection(Vector<bool>) method

/// This method sets a new population selection Vector.
///
/// @param newSelection: Population selection values.

void GeneticAlgorithm::setSelection(Vector<bool> newSelection)
{
   if(newSelection.getSize() != populationSize)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void setSelection(Vector<double>) method." << std::endl
                << "Size is not equal to population size." << std::endl
                << std::endl;

      exit(1);
   }
   else
   {
      selection = newSelection;
   }
}


// Vector<double> getIndividual(int) method

/// This method returns the Vector of free parameters corresponding to the individual i in the population.
///
/// @param i: Index of individual in the population.

Vector<double> GeneticAlgorithm::getIndividual(int i)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> individual(numberOfVariables, 0.0);

   for(int j = 0; j < numberOfVariables; j++)
   {
      individual[j] = population[i][j];
   }

   return(individual);
}


// setIndividual(int, Vector<double>) method

/// This method sets a new Vector of free parameters to the individual i in the population. 
///
/// @param i: Index of individual in the population.
/// @param individual: Vector of free parameters to be assigned to individual i.

void GeneticAlgorithm::setIndividual(int i, Vector<double> individual)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   for(int j = 0; j < numberOfVariables; j++)
   {
      population[i][j] = individual[j];
   }
}


// Training parameters

// double getSelectivePressure(void) method

/// This method returns the selective pressure value.
///
/// @see performLinearRankingFitnessAssignment(void).
/// @see performNonLinearRankingFitnessAssignment(void).

double GeneticAlgorithm::getSelectivePressure(void)
{
   return(selectivePressure);
}


// double getRecombinationSize(void) method

/// This method returns the recombination size value.
///
/// @see performIntermediateRecombination(void)
/// @see performLineRecombination(void).

double GeneticAlgorithm::getRecombinationSize(void)
{
   return(recombinationSize);
}


// double getMutationRate(void) method

/// This method returns the mutation rate value.
///
///  @see performNormalMutation(void).
///  @see performUniformMutation(void).

double GeneticAlgorithm::getMutationRate(void)
{
   return(mutationRate);
}


// double getMutationRange(void) method

/// This method returns the mutation range value.
///
///  @see performNormalMutation(void).
///  @see performUniformMutation(void).

double GeneticAlgorithm::getMutationRange(void)
{
   return(mutationRange);
}


// FitnessAssignmentMethod getFitnessAssignmentMethod(void) method

/// This method returns the fitness assignment method used for training.
///
/// @see performLinearRankingFitnessAssignment(void).
/// @see performNonLinearRankingFitnessAssignment(void).
/// @see train(void).
 
GeneticAlgorithm::FitnessAssignmentMethod
GeneticAlgorithm::getFitnessAssignmentMethod(void)
{
   return(fitnessAssignmentMethod);
}


// SelectionMethod getSelectionMethod(void) method

/// This method returns the selection method used for training.
///
/// @see performRouletteWheelSelection(void).
/// @see performStochasticUniversalSamplingSelection(void).
/// @see train(void).

GeneticAlgorithm::SelectionMethod GeneticAlgorithm::getSelectionMethod(void)
{
   return(selectionMethod);
}


// RecombinationMethod getRecombinationMethod(void) method

/// This method returns the recombination method used for training.
///
/// @see performIntermediateRecombination(void).
/// @see performLineRecombination(void).
/// @see train(void).

GeneticAlgorithm::RecombinationMethod GeneticAlgorithm::getRecombinationMethod(void)
{
   return(recombinationMethod);
}


// MutationMethod getMutationMethod(void) method

/// This method returns the mutation method used for training.
///
/// @see performNormalMutation(void).
/// @see performUniformMutation(void).
/// @see train(void).

GeneticAlgorithm::MutationMethod GeneticAlgorithm::getMutationMethod(void)
{
   return(mutationMethod);
}


// void setSelectivePressure(double) method

/// This method sets a new value for the selective pressure parameter.
/// Linear ranking allows values for the selective pressure between 1 and 2.
/// Non linear ranking allows values for the selective pressure between 1
/// and [population size] - 2.
///
/// @param newSelectivePressure: Selective pressure value. This must be between 1 and 2 
/// for linear ranking fitness assignment and between 1 1 and [population size] - 2 
/// for non linear ranking fitness assignment. 
///
/// @see performLinearRankingFitnessAssignment(void).
/// @see performNonLinearRankingFitnessAssignment(void).

void GeneticAlgorithm::setSelectivePressure(double newSelectivePressure)
{
   switch(fitnessAssignmentMethod)
   {
      case LinearRanking:

         if((newSelectivePressure < 1.0) || (newSelectivePressure > 2.0))
         {
            std::cout << std::endl
                      << "Error: GeneticAlgorithm class. "
                      << "void setSelectivePressure(double) method. "
                      << "Case linear ranking." << std::endl
                      << "Selective pressure must be a value between 1 and 2."
                      << std::endl << std::endl;

            exit(1);
         }

         selectivePressure = newSelectivePressure;

      break;

      case NonLinearRanking:

         if((newSelectivePressure < 1.0) || (newSelectivePressure > populationSize-2))
         {
            std::cout << std::endl
                      << "Error: GeneticAlgorithm class. "
                      << "void setSelectivePressure(double) method. "
                      << "Case non linear ranking." << std::endl
                      << "Selective pressure must be a value between 1 "
                      << "and population size - 2."
                      << std::endl << std::endl;

            exit(1);
         }

         selectivePressure = newSelectivePressure;

      break;
   }
}


// void setRecombinationSize(double) method

/// This method sets a new value for the recombination size parameter.
/// The recombination size value must be equal or greater than 0.
///
/// @param newRecombinationSize: Recombination size value. This must be equal or greater than 0.
///
/// @see performIntermediateRecombination(void)
/// @see performLineRecombination(void).

void GeneticAlgorithm::setRecombinationSize(double newRecombinationSize)
{
   if(newRecombinationSize < 0.0)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void setRecombinationSize(double) method." << std::endl
                << "Recombination size must be equal or greater than 0." << std::endl
                << std::endl;

      exit(1);
   }

   recombinationSize = newRecombinationSize;
}


// void setMutationRate(double) method

/// This method sets a new value for the mutation rate parameter.
/// The mutation rate value must be between 0 and 1.
///
/// @param newMutationRate: Mutation rate value. This must be equal or greater than 0
/// less or equal to 1. 
///
///  @see performNormalMutation(void).
///  @see performUniformMutation(void).

void GeneticAlgorithm::setMutationRate(double newMutationRate)
{
   if(newMutationRate < 0.0 || newMutationRate > 1.0)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void setMutationRate(double) method." << std::endl
                << "Mutation rate must be a value between 0 and 1. " << std::endl
                << std::endl;

      exit(1);
   }

   mutationRate = newMutationRate;
}


// void setMutationRange(double) method

/// This method sets a new value for the mutation range parameter.
/// The mutation range value must be 0 or a positive number. 
///
/// @param newMutationRange: Mutation range value. This must be equal or greater than 0.
///
///  @see performNormalMutation(void).
///  @see performUniformMutation(void).

void GeneticAlgorithm::setMutationRange(double newMutationRange)
{
   if(newMutationRange < 0.0)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void setMutationRange(double) method." << std::endl
                << "Mutation range must be equal or greater than 0. " << std::endl
                << std::endl;

      exit(1);
   }

   mutationRange = newMutationRange;
}


// void setFitnessAssignmentMethod(FitnessAssignmentMethod) method

/// This method sets a new fitness assignment method to be used for training.
///
/// @param newFitnessAssignmentMethod: Fitness assignment method chosen for training.
///
/// @see performLinearRankingFitnessAssignment(void).
/// @see performNonLinearRankingFitnessAssignment(void).

void GeneticAlgorithm::setFitnessAssignmentMethod
(GeneticAlgorithm::FitnessAssignmentMethod newFitnessAssignmentMethod)
{
   fitnessAssignmentMethod = newFitnessAssignmentMethod;
}


// void setSelectionMethod(SelectionMethod) method

/// This method sets a new selection method to be used for training.
///
/// @param newSelectionMethod: Selection method chosen for training.
///
/// @see performRouletteWheelSelection(void).
/// @see performStochasticUniversalSamplingSelection(void).

void GeneticAlgorithm::setSelectionMethod
(GeneticAlgorithm::SelectionMethod newSelectionMethod)
{
   selectionMethod = newSelectionMethod;
}


// void setRecombinationMethod(RecombinationMethod) method

/// This method sets a new recombination method to be used for training.
///
/// @param newRecombinationMethod: Recombination method chosen for training. 
///
/// @see performIntermediateRecombination(void).
/// @see performLineRecombination(void).

void GeneticAlgorithm::setRecombinationMethod
(GeneticAlgorithm::RecombinationMethod newRecombinationMethod)
{
   recombinationMethod = newRecombinationMethod;
}


// void setMutationMethod(MutationMethod) method

/// This method sets a new mutation method to be used for training.
///
/// @param newMutationMethod: Mutation method chosen for training. 
///
/// @see performNormalMutation(void).
/// @see performUniformMutation(void).


void GeneticAlgorithm::setMutationMethod
(GeneticAlgorithm::MutationMethod newMutationMethod)
{
   mutationMethod = newMutationMethod;
}


// void initPopulationAtRandom(void) method
//
/// This method initializes all the individuals in the population at 
/// random, with values comprised between -1 and 1.
///
/// @see initPopulationAtRandom(double, double).
/// @see initPopulationAtRandom(Vector<double>, Vector<double>).
/// @see initPopulationAtRandom(Matrix<double>).

void GeneticAlgorithm::initPopulationAtRandom(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> individual(numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      for(int j = 0; j < numberOfVariables; j++)
      {
         double random = (double)rand()/(RAND_MAX+1.0);

         individual[j] = -1.0 + 2.0*random;
      }

      setIndividual(i, individual);
   }
}


// void initPopulationAtRandom(double, double) method
//
/// This method initializes all the individuals in the population at 
/// random, with values comprised between a minimum and a maximum value.
///
/// @param minimumValue: Minimum initialization value.
/// @param maximumValue: Maximum initialization value.
///
/// @see initPopulationAtRandom(void).
/// @see initPopulationAtRandom(Vector<double>, Vector<double>).
/// @see initPopulationAtRandom(Matrix<double>).

void GeneticAlgorithm
::initPopulationAtRandom(double minimumValue, double maximumValue)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> individual(numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      for(int j = 0; j < numberOfVariables; j++)
      {
         double random = (double)rand()/(RAND_MAX+1.0);

         individual[j] = minimumValue + (maximumValue-minimumValue)*random;
      }

      setIndividual(i, individual);
   }
}


// void initPopulationAtRandom(Vector<double>, Vector<double>) method

/// This method initializes the free parameters of all the individuals in the population at 
/// random, with values comprised between different minimum and maximum values 
/// for each variable.
///
/// @param minimumValue: Minimum initialization value.
/// @param maximumValue: Maximum initialization value.
///
/// @see initPopulationAtRandom(void).
/// @see initPopulationAtRandom(double, double).
/// @see initPopulationAtRandom(Matrix<double>).

void GeneticAlgorithm::initPopulationAtRandom(Vector<double> minimumValue, Vector<double> maximumValue)
{
   int minimumValueSize = minimumValue.getSize();
   int maximumValueSize = maximumValue.getSize();

   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   if(minimumValueSize != numberOfVariables || maximumValueSize != numberOfVariables)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class." 
                << "void initPopulationAtRandom(Vector<double>, Vector<double>)."
                << std::endl
                << "Minimum value and maximum value sizes must be equal to number of free parameters." 
                << std::endl << std::endl;
 
      exit(1);
   }

   Vector<double> individual(numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      for(int j = 0; j < numberOfVariables; j++)
      {
         double random = (double)rand()/(RAND_MAX+1.0);

         individual[j] = minimumValue[j] + (maximumValue[j]-minimumValue[j])*random;
      }

      setIndividual(i, individual);
   }
}

// void initPopulationAtRandom(Matrix<double>) method

/// This method initializes the free parameters of all the individuals in the population at 
/// random, with values comprised between different minimum and maximum values 
/// for each variable and from a single Matrix.
///
/// @param minimumAndMaximumValues: Minimum and maximum initialization values.
///
/// @see initPopulationAtRandom(void).
/// @see initPopulationAtRandom(double, double).
/// @see initPopulationAtRandom(Vector<double>, Vector<double>).

void GeneticAlgorithm::initPopulationAtRandom(Matrix<double> minimumAndMaximumValues)
{
   int numberOfRows = minimumAndMaximumValues.getNumberOfRows();
   int numberOfColumns = minimumAndMaximumValues.getNumberOfColumns();

   int numberOfVariables = objectiveFunction->getNumberOfVariables();


   if(numberOfRows != 2 || numberOfColumns != numberOfVariables)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class." 
                << "void initPopulationAtRandom(Matrix<double>)." << std::endl
                << "Number of rows must be two and number of columns must be equal to "
                << "number of free parameters." 
                << std::endl << std::endl;
 
      exit(1);
   }

   Vector<double> minimumValue(numberOfVariables, 0.0);
   Vector<double> maximumValue(numberOfVariables, 0.0);

   for(int i = 0; i < numberOfVariables; i++)
   {
      minimumValue[i] = minimumAndMaximumValues[0][i];
      maximumValue[i] = minimumAndMaximumValues[1][i];
   }

   Vector<double> individual(numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      for(int j = 0; j < numberOfVariables; j++)
      {
         double random = (double)rand()/(RAND_MAX+1.0);

         individual[j] = minimumValue[j] + (maximumValue[j]-minimumValue[j])*random;
      }

      setIndividual(i, individual);
   }
}


// void evaluatePopulation(void) method
//
/// This method evaluates the performance of all individuals in the
/// population. Results are stored in the performance Vector.
///
/// @see train(void).

void GeneticAlgorithm::evaluatePopulation(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> individual(numberOfVariables, 0.0);

   // Evaluate performance of all individuals

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      evaluation[i] = objectiveFunction->getEvaluation(individual);
   }
}


// void performLinearRankingFitnessAssignment(void) method
//
/// This method ranks all individuals in the population by their
/// performance, so that the least fit individual has rank 1 and the
/// fittest individual has rank [population size].
/// It then assigns them a fitness value linearly proportional to their
/// rank. Results are stored in the fitness Vector.
///
/// @see performNonLinearRankingFitnessAssignment(void).
/// @see train(void).

void GeneticAlgorithm::performLinearRankingFitnessAssignment(void)
{
   // Sorted performance vector

   Vector<double> sortedEvaluation(populationSize, 0.0);

   sortedEvaluation = evaluation;

   std::sort(sortedEvaluation.begin(), sortedEvaluation.end(), std::less<double>());

   // Rank vector

   Vector<int> rank(populationSize, 0);

   for(int i = 0; i < populationSize; i++)
   {
      for(int j = 0; j < populationSize; j++)
      {
         if(evaluation[j] == sortedEvaluation[i])
         {
            rank[j] = populationSize - i;
         }
      }
   }

   // Perform linear ranking fitness assignment

   for(int i = 0; i < populationSize; i++)
   {
      fitness[i] = 2.0 - selectivePressure
      + 2.0*(selectivePressure - 1.0)*(rank[i] - 1.0)/(populationSize - 1.0);
   }
}


// void performNonLinearRankingFitnessAssignment(void) method
//
/// This method ranks all individuals in the population by their 
/// performance, so that the least fit individual has rank 1 and the 
/// fittest individual has rank population size.
/// Please, do not use this method. It is not yet implemented.
///
/// @see performLinearRankingFitnessAssignment(void).
/// @see train(void).

void GeneticAlgorithm::performNonLinearRankingFitnessAssignment(void)
{
   std::cout << std::endl
             << "Error: GeneticAlgorithm class. "
             << "void performNonLinearRankingFitnessAssignment(void) method." << std::endl
             << "Sorry, this method is not yet implemented." << std::endl
             << std::endl;

   exit(1);


   // Sorted performance vector

   Vector<double> sortedEvaluation(populationSize, 0.0);

   sortedEvaluation = evaluation;

   std::sort(sortedEvaluation.begin(), sortedEvaluation.end(), std::less<double>());

   // Rank vector.

   Vector<int> rank(populationSize, 0);

   for(int i = 0; i < populationSize; i++)
   {
      for(int j = 0; j < populationSize; j++)
      {
         if(evaluation[j] == sortedEvaluation[i])
         {
            rank[j] = populationSize - i;
         }
      }
   }

   // Perform non-linear ranking fitness assignment

   double x = 0.0;

   for(int i = 0; i < populationSize; i++)
   {
      double numerator = populationSize*pow(x, rank[i]-1);

      double denominator = 0.0;

      for(int j = 0; j < populationSize; j++)
      {
         denominator += pow(x, j-1);
      }

      fitness[i] = numerator/denominator;
   }
}


// void performRouletteWheelSelection(void) method

/// This metod performs selection with roulette wheel selection. It 
/// selects half of the individuals from the population. Results are
/// stored in the selection Vector. 
///
/// @see performStochasticUniversalSamplingSelection(void) method
/// @see train(void).

void GeneticAlgorithm::performRouletteWheelSelection(void)
{
   // Set selection vector to false 

   for(int i = 0; i < populationSize; i++)
   {
      selection[i] = false;
   }

   int numberOfSelectedIndividuals = populationSize/2;

   Vector<double> cumulativeFitness(populationSize, 0.0);

   Vector<double> pointer(numberOfSelectedIndividuals, 0.0);

   // Cumulative fitness vector

   cumulativeFitness[0] = fitness[0]; 

   for(int i = 1; i < populationSize; i++)
   {
      cumulativeFitness[i] = cumulativeFitness[i-1] + fitness[i];
   }

   // Select individuals until the desired number of selections is obtained

   int countNumberOfSelectedIndividuals = 0;

   do
   {
      // Random number between 0 and total cumulative fitness

      double random = (double)rand()/(RAND_MAX+1.0);

      pointer[countNumberOfSelectedIndividuals] = cumulativeFitness[populationSize-1]*random;

      // Perform selection

      if((pointer[countNumberOfSelectedIndividuals] < cumulativeFitness[0]))
      {
         if(selection[0] == false)
         {
            selection[0] = true;
            countNumberOfSelectedIndividuals++;
         }
      }
      for(int i = 1; i < populationSize; i++)
      {
         if((pointer[countNumberOfSelectedIndividuals] < cumulativeFitness[i])
         && (pointer[countNumberOfSelectedIndividuals] > cumulativeFitness[i-1]))
         {
            if(selection[i] == false)
            {
               selection[i] = true;
               countNumberOfSelectedIndividuals++;
            }
         }
      }
   }while(countNumberOfSelectedIndividuals < numberOfSelectedIndividuals);

   if(countNumberOfSelectedIndividuals != numberOfSelectedIndividuals)
   {
      std::cout << std::endl 
                << "Error: GeneticAlgorithm class. "
                << "void performRouletteWheelSelection(void) method."
                << std::endl
                << "Count number of selected individuals is not equal to "
                << "number of selected individuals."
                << std::endl << std::endl;

      exit(1);
   }
}


// void performStochasticUniversalSamplingSelection(void) method
//
/// This metod performs selection with stochastic universal sampling. It 
/// selects half of the individuals from the population. Results are
/// stored in the selection vector. 
///
/// @see performRouletteWheelSelection(void) method.
/// @see train(void).

void GeneticAlgorithm::performStochasticUniversalSamplingSelection(void)
{
   // Set selection vector to false

   for(int i = 0; i < populationSize; i++)
   {
      selection[i] = false;
   }
 
   int numberOfSelectedIndividuals = populationSize/2;

   Vector<double> cumulativeFitness(populationSize, 0.0);

   Vector<double> pointer(numberOfSelectedIndividuals, 0.0);

   // Cumulative fitness vector

   cumulativeFitness[0] = fitness[0];

   for(int i = 1; i < populationSize; i++)
   {  

      cumulativeFitness[i] = cumulativeFitness[i-1] + fitness[i];
   }


// Pointer vector

// Random number between 0 and totalCumulativeFitnees/numberOfSelectedIndividuals 

   double random = (double)rand()/(RAND_MAX+1.0);

   pointer[0] = random
   *cumulativeFitness[populationSize-1]/(1.0*numberOfSelectedIndividuals);

   for(int i = 1; i < numberOfSelectedIndividuals; i++)
   {
      pointer[i] = pointer[i-1] 
      + cumulativeFitness[populationSize-1]/(1.0*numberOfSelectedIndividuals);
   }

   // Selection vector

   int countNumberOfSelectedIndividuals = 0;

   for(int i = 0; i < numberOfSelectedIndividuals; i++)
   {
      if(pointer[i] < cumulativeFitness[0])
      {
         selection[0] = true;
         countNumberOfSelectedIndividuals++;
      }

      for(int j = 1; j < populationSize; j++)
      {
         if(pointer[i] < cumulativeFitness[j] && pointer[i] > cumulativeFitness[j-1])
         {
            selection[j] = true;
            countNumberOfSelectedIndividuals++;
         }
      }
   }

   // Number of selected individuals control sentence 

   if(countNumberOfSelectedIndividuals != numberOfSelectedIndividuals)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class." << std::endl
                << "void performStochasticUniversalSamplingSelection(void) method."
                << std::endl
                << "Count number of selected individuals is not equal to number of selected individuals." 
                << std::endl << std::endl;

      exit(1);
   }
}


// void performIntermediateRecombination(void) method

/// This method performs intermediate recombination between pairs
/// of selected individuals to generate a new population. Each selected
/// individual is to be recombined with two other selected individuals
/// chosen at random. Results are stored in the population matrix.
///
/// @see recombinationSize.
///
/// @see performLineRecombination(void).
/// @see train(void).

void GeneticAlgorithm::performIntermediateRecombination(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Matrix<double> newPopulation(populationSize, numberOfVariables, 0.0);

   int numberOfSelectedIndividuals = populationSize/2;

   Vector<double> parent1(numberOfVariables, 0.0);
   Vector<double> parent2(numberOfVariables, 0.0);

   Vector<double> offspring(numberOfVariables, 0.0);

   Matrix<int> recombination(populationSize, 2, 0);

   // Start recombination       

   int countNewPopulationSize = 0;

   for(int i = 0; i < populationSize; i++)
   {
      if(selection[i] == true)
      {
         // Set parent 1

         parent1 = getIndividual(i);

         // Generate 2 offspring with parent 1

         for(int j = 0; j < 2; j++)
         {
            // Choose parent 2 at random among selected individuals     

            bool candidateForParent2IsOk = false;

            do{
               // Integer random number beteen 0 and population size

               double random = (double)rand()/(RAND_MAX+1.0);

               int candidateForParent2Index = (int)(populationSize*random);

               // Check if candidate for parent 2 is ok

               if(selection[candidateForParent2Index] == true && candidateForParent2Index != i)
               {
                  candidateForParent2IsOk = true;

                  recombination[countNewPopulationSize][0] = i;

                  recombination[countNewPopulationSize][1]
                  = candidateForParent2Index;

                  parent2 = getIndividual(candidateForParent2Index);

                  // Perform intermediate recombination between parent 1
                  // and parent 2

                  for(int j = 0; j < numberOfVariables; j++)
                  {
                     // Choose the scaling factor to be a random number between
                     // -recombinationSize and 1+recombinationSize for each
                     // variable anew.

                     double random = (double)rand()/(RAND_MAX+1.0);

                     double scalingFactor = -1.0*recombinationSize
                     + (1.0 + recombinationSize)*random;

                     offspring[j] = scalingFactor*parent1[j]
                     + (1.0 - scalingFactor)*parent2[j];
                  }

                  // Add offspring to newPopulation matrix

                  for(int j = 0; j < numberOfVariables; j++)
                  {
                     newPopulation[countNewPopulationSize][j] = offspring[j];   
                  }

                  countNewPopulationSize++;
               }
            }while(candidateForParent2IsOk == false);
         }
      }
   }

   // Count number of new individuals control sentence

   if(countNewPopulationSize != populationSize)
   {
      std::cout << std::endl 
                << "Error: GeneticAlgorithm class. void performIntermediateRecombination(void) method." 
                << std::endl
                << "Count new population size is not equal to population size." << std::endl
                << std::endl;

      exit(1);
   }

   // Set new population

   population = newPopulation;
}


// void performLineRecombination(void) method

/// This method performs line recombination between pairs
/// of selected individuals to generate a new population. Each selected
/// individual is to be recombined with two other selected individuals
/// chosen at random. Results are stored in the population matrix.
///
/// @see recombinationSize.
///
/// @see performIntermediateRecombination(void).
/// @see train(void).

void GeneticAlgorithm::performLineRecombination(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Matrix<double> newPopulation(populationSize, numberOfVariables, 0.0);

   int numberOfSelectedIndividuals = populationSize/2;

   Vector<double> parent1(numberOfVariables, 0.0);
   Vector<double> parent2(numberOfVariables, 0.0);

   Vector<double> offspring(numberOfVariables, 0.0);

   Matrix<int> recombination(populationSize, 2, 0);

   // Start recombination       

   int countNewPopulationSize = 0;

   for(int i = 0; i < populationSize; i++)
   {
      if(selection[i] == true)
      {

         // Set parent 1

         parent1 = getIndividual(i);

         // Generate 2 offspring with parent 1

         for(int j = 0; j < 2; j++)
         {
            // Choose parent 2 at random among selected individuals     

            bool candidateForParent2IsOk = false;

            do
            {
               // Integer random number beteen 0 and population size

               int random = (int)((double)rand()/(RAND_MAX+1.0));

               int candidateForParent2Index = populationSize*random;

               // Check if candidate for parent 2 is ok

               if(selection[candidateForParent2Index] == true
               && candidateForParent2Index != i)
               {
                  candidateForParent2IsOk = true;

                  recombination[countNewPopulationSize][0] = i;
                  recombination[countNewPopulationSize][1] = candidateForParent2Index;

                  parent2 = getIndividual(candidateForParent2Index);

                  // Perform intermediate recombination between parent 1
                  // and parent 2

                  // Choose the scaling factor to be a random number between
                  // -recombinationSize and 1+recombinationSize for all
                  // variables.

                  double random = (double)rand()/(RAND_MAX+1.0);

                  double scalingFactor = -1.0*recombinationSize 
                  + (1.0 + recombinationSize)*random;

                  for(int j = 0; j < numberOfVariables; j++)
                  {
                     offspring[j] = scalingFactor*parent1[j]
                     + (1.0 - scalingFactor)*parent2[j];
                  }

                  // Add offspring to newPopulation matrix

                  for(int j = 0; j < numberOfVariables; j++)
                  {
                     newPopulation[countNewPopulationSize][j] = offspring[j];   
                  }

                  countNewPopulationSize++;
               }
            }while(candidateForParent2IsOk == false);
         }
      }
   }

   // Count new population size control sentence

   if(countNewPopulationSize != populationSize)
   {
      std::cout << std::endl
                << "Error:  GeneticAlgorithm class. "
                << "void performLineRecombination(void) method."
                << std::endl
                << "Count new population size is not equal to population size."
                << std::endl << std::endl;

      exit(1);
   }

   // Set new population

   population = newPopulation;
}


// void performNormalMutation(void) method

/// This method performs normal mutation to all individuals in order to generate
/// a new population. It uses the Box-Muller transformation to generate
/// random numbers with normal distribution. Results are stored in the
/// population matrix.
///
/// @see mutationRate.
/// @see mutationRange.
///
/// @see performUniformMutation(void).
/// @see train(void).

void GeneticAlgorithm::performNormalMutation(void)
{
   const double pi = 3.141592654;

   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> individual(numberOfVariables, 0.0);

   Matrix<double> mutation(populationSize, numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      for(int j = 0; j < numberOfVariables; j++)
      {
         // Random number between 0 and 1

         double pointer = (double)rand()/(RAND_MAX+1.0);

         if(pointer < mutationRate)
         {
            // Random numbers between 0 and 1

            double random1 = (double)rand()/(RAND_MAX+1.0);
            double random2 = (double)rand()/(RAND_MAX+1.0);

            // Box-Muller transformation

            double mean = 0.0;
            double standardDeviation = mutationRange;

            double normallyDistributedRandomNumber 
            = mean + sqrt(-2.0*log(random1))*sin(2.0*pi*random2)*standardDeviation;

            individual[j] += normallyDistributedRandomNumber;

            mutation[i][j] = normallyDistributedRandomNumber;
         }
      }

      setIndividual(i, individual);
   }
}


// void performUniformMutation(void) method

/// This method performs uniform mutation to all individuals in order to generate
/// a new population. Results are stored in the population matrix.
///
/// @see mutationRate.
/// @see mutationRange.
///
/// @see performNormalMutation(void).
/// @see train(void).

void GeneticAlgorithm::performUniformMutation(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> individual(numberOfVariables, 0.0);

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      for(int j = 0; j < numberOfVariables; j++)
      {
         // random number between 0 and 1

         double pointer = (double)rand()/(RAND_MAX+1.0);

         if(pointer < mutationRate)
         {
            // random number between 0 and 1

            double random = (double)rand()/(RAND_MAX+1.0);

            double uniformlyDistributedRandomNumber
            = (-1.0 + 2.0*random)*mutationRange;

            individual[j] += uniformlyDistributedRandomNumber;
         }
      }

      setIndividual(i, individual);
   }
}


// Vector<double> GeneticAlgorithm::getMinimalArgument(void) method

/// This method trains a multilayer perceptron with an associated
/// performance function according to the genetic algorithm.
/// Training occurs according to the training operators and their related
/// parameters.
///
/// @see FitnessAssignmentMethod.
/// @see SelectionMethod.
/// @see RecombinationMethod.
/// @see MutationMethod.

Vector<double> GeneticAlgorithm::getMinimalArgument(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   Vector<double> minimalArgument(numberOfVariables, 0.0);

   // Mean performance training history vector

   Vector<double> newMeanEvaluationHistory(maximumNumberOfGenerations, 0.0);

   meanEvaluationHistory = newMeanEvaluationHistory;

   // Standard deviation of performance training history vector

   Vector<double> newStandardDeviationEvaluationHistory(maximumNumberOfGenerations, 0.0);

   standardDeviationEvaluationHistory = newStandardDeviationEvaluationHistory;

   // Best performance training history vector

   Vector<double> newBestEvaluationHistory(maximumNumberOfGenerations, 0.0);

   bestEvaluationHistory = newBestEvaluationHistory;

   Vector<double> bestIndividual(numberOfVariables, 0.0);

   double bestEvaluation = 1.0e69;

   time_t beginningTime, currentTime;

   double elapsedTime = 0.0;

   // Set beginning training time

   time(&beginningTime);

   // Main loop

   for(int generation = 0; generation < maximumNumberOfGenerations; generation++)
   {
      // Performance evaluation

      evaluatePopulation();

      // Check for best individual

      for(int i = 0; i < populationSize; i++)
      {
         if(evaluation[i] < bestEvaluation)
         {
            bestEvaluation = evaluation[i];

            bestIndividual = getIndividual(i);

            // Set best individual free paramterers to multilayer perceptron

            minimalArgument = bestIndividual;
         }
      }

      bestEvaluationHistory[generation] = bestEvaluation;


      // Calculate mean population performance

      double meanEvaluation = 0.0;

      double sum1 = 0.0;

      for(int i = 0; i < populationSize; i++)
      {
         sum1 += evaluation[i];
      }

      meanEvaluation = sum1/populationSize;

      meanEvaluationHistory[generation] = meanEvaluation;

      // Calculate standard deviation of performance

      double standardDeviationEvaluation = 0.0;

      double sum2 = 0.0;

      for(int i = 0; i < populationSize; i++)
      {
         sum2 += pow(evaluation[i] - meanEvaluation, 2);
      }

      standardDeviationEvaluation = sqrt(sum2/populationSize);

      standardDeviationEvaluationHistory[generation] = standardDeviationEvaluation;

      // Stopping Criteria

      // Performance goal 

      if (bestEvaluation <= evaluationGoal)
      {
         if (generation == 0)
         {
            std::cout << std::endl
                      << "Initial evaluation is less than goal."
                      << std::endl;
         }
         else
         {
            std::cout << std::endl
                      << "Generation " << generation << ": "
                      << "Evaluation goal reached." << std::endl;

            std::cout << "Final evaluation:" << std::endl;
         }

         std::cout << "Evaluation: " << bestEvaluation << ";" << std::endl;

         break;
      }

      // Maximum training time

      time(&currentTime);

      elapsedTime = difftime(currentTime, beginningTime);

      if (elapsedTime >= maximumTime)
      {
         std::cout << std::endl
                   << "Generation " << generation << ": "
                   << "Maximum time reached."
                   << std::endl;

         std::cout << "Final evaluation:" << std::endl;

         std::cout << "Evaluation: " << bestEvaluation << ";" << std::endl;

         break;
      }

      // Maximum number of iterations

      if (generation == (maximumNumberOfGenerations - 1))
      {
         std::cout << std::endl
                   << "Generation " << generation << ": "
                   << "Maximum number of generations reached."
                   << std::endl;

         std::cout << "Final performance:" << std::endl;

         std::cout << "Evaluation: " << bestEvaluation << ";" << std::endl;

         break;
      }

      // Progress

      if(generation == 0)
      {
         std::cout << std::endl
                   << "Genetic algorithm..."  << std::endl
                   << std::endl
                   << "Generation " << generation << "; " << std::endl
                   << "Population:" << std::endl
                   << "Mean performance: " << meanEvaluation << std::endl
                   << "Standard deviation of performance: " << standardDeviationEvaluation
                   << std::endl
                   << "Best individual: " << std::endl;

         std::cout << "Evaluation: " << bestEvaluation << ";" << std::endl;
      }
      else if(generation % showPeriod == 0)
      {
         std::cout << std::endl
                   << "Generation " << generation << "; " << std::endl
                   << "Population: "
                   << "Mean evaluation: " << meanEvaluation << std::endl
                   << "Standard deviation of evaluation: " << standardDeviationEvaluation
                   << std::endl
                   << "Best individual: " << std::endl;

         std::cout << "Evaluation: " << bestEvaluation << ";" << std::endl;
      }

      // Fitness assignment

      switch(fitnessAssignmentMethod)
      {
         case LinearRanking:

            performLinearRankingFitnessAssignment();

            break;

         case NonLinearRanking:

            performNonLinearRankingFitnessAssignment();

            break;
      }

      // Selection

      switch(selectionMethod)
      {
         case RouletteWheel:

            performRouletteWheelSelection();

            break;

         case StochasticUniversalSampling:

            performStochasticUniversalSamplingSelection();

            break;
      }

      // Recombination

      switch(recombinationMethod)
      {
         case Intermediate:

            performIntermediateRecombination();

            break;

         case Line:

            performLineRecombination();

            break;
      }

      // Mutation

      switch(mutationMethod)
      {
         case Normal:

            performNormalMutation();

            break;

         case Uniform:

            performUniformMutation();

            break;

      }

      // Reset selection vector

      Vector<bool> newSelection(populationSize, false);

      selection = newSelection;
   }

   return(minimalArgument);

}


// void print(void) method

/// This method prints to the screen the members of the genetic algorithm object.
///
/// Training operators:
/// <ul>
/// <li> Fitness assignment method.
/// <li> Selection method.
/// <li> Recombination method.
/// <li> Mutation method.
/// </ul>
///
/// Training parameters:
/// <ul>
/// <li> Population size.
/// <li> Selective pressure.
/// <li> Recombination size.
/// <li> Mutation rate.
/// <li> Mutation range.
/// </ul>
///
/// Stopping criteria:
/// <ul> 
/// <li> Performance goal.
/// <li> Maximum training time.
/// <li> Maximum number of iterations.
/// </ul> 
///  
/// User stuff: 
/// <ul>
/// <li> Iterations between showing progress.
/// </ul>

void GeneticAlgorithm::print(void)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   std::cout << std::endl
             << "Flood Neural Network. Genetic Algorithm Object." << std::endl;

   std::cout << std::endl
             << "Population size: " << std::endl
             << populationSize << std::endl
             << "Number of free parameters: " << std::endl
             << numberOfVariables  << std::endl;

   // Training operators

   std::cout << std::endl
             << "Training operators:" << std::endl;

   // Fitness assingment method

   std::cout << "Fitness assignment method:" << std::endl;

   if(fitnessAssignmentMethod == LinearRanking)
   {
      std::cout << "Linear ranking" << std::endl;
   }
   else if(fitnessAssignmentMethod == NonLinearRanking)
   {
      std::cout << "Non linear ranking" << std::endl;
   }

   // Selection method

   std::cout << "Selection method:" << std::endl;

   if(selectionMethod == RouletteWheel)
   {
      std::cout << "Roulette wheel" << std::endl;
   }
   else if(selectionMethod == StochasticUniversalSampling)
   {
      std::cout << "Stochastic universal sampling" << std::endl;
   }

   // Recombination method

   std::cout << "Recombination method:" << std::endl;

   if(recombinationMethod == Line)
   {
      std::cout << "Line" << std::endl;
   }
   else if(recombinationMethod == Intermediate)
   {
      std::cout << "Intermediate" << std::endl;
   }

   // Mutation method

   std::cout << "Mutation method:" << std::endl;

   if(mutationMethod == Normal)
   {
      std::cout << "Normal" << std::endl;
   }
   else if(mutationMethod == Uniform)
   {
      std::cout << "Uniform" << std::endl;
   }


   // Training parameters

   std::cout << std::endl
             << "Training parameters: " << std::endl
             << "Selective pressure: " << std::endl
             << selectivePressure << std::endl
             << "Recombination size: " << std::endl
             << recombinationSize << std::endl
             << "Mutation rate: " << std::endl
             << mutationRate << std::endl
             << "Mutation range: " << std::endl
             << mutationRange << std::endl;

   // Stopping criteria

   std::cout << std::endl
             << "Stopping criteria: " << std::endl
             << "Evaluation goal: " << std::endl
             << evaluationGoal << std::endl
             << "Maximum time: " << std::endl
             << maximumTime << std::endl
             << "Maximum number of generations: " << std::endl
             << maximumNumberOfGenerations << std::endl;

   // User stuff

   std::cout << std::endl
             << "User stuff: " << std::endl
             << "Show period: " << showPeriod
             << std::endl;

   Vector<double> individual(numberOfVariables, 0.0);

   std::cout << std::endl
             << "Population:" << std::endl;

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      std::cout << "Individual " << i << ":" << std::endl; 

      for(int j = 0; j < numberOfVariables; j++)
      {
         std::cout << individual[j] << " ";
      }

      std::cout << std::endl;
   }
}


// void save(char*) method

/// This method saves the genetic algorithm object to a data file. 
///
/// Training operators:
/// <ul>
/// <li> Fitness assignment method.
/// <li> Selection method.
/// <li> Recombination method.
/// <li> Mutation method.
/// </ul>
///
/// Training parameters:
/// <ul>
/// <li> Population size.
/// <li> Selective pressure.
/// <li> Recombination size.
/// <li> Mutation rate.
/// <li> Mutation range.
/// </ul>
///
/// Stopping criteria:
/// <ul> 
/// <li> Performance goal.
/// <li> Maximum training time.
/// <li> Maximum number of iterations.
/// </ul> 
///  
/// User stuff: 
/// <ul>
/// <li> Iterations between showing progress.
/// </ul>
///
/// @param filename: Filename.
///
/// @see load(char*).

void GeneticAlgorithm::save(char* filename)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   // File

   std::fstream file;

   file.open(filename, std::ios::out);

   if(!file.is_open())
   {
      std::cout << std::endl 
                << "Error: GeneticAlgorithm class. void save(char*) method." << std::endl
                << "Cannot open genetic algorithm object data file."  << std::endl
                << std::endl;

      exit(1);
   }
   else
   {
      std::cout << std::endl
                << "Saving genetic algorithm object to data file..." << std::endl;
   }

   // Write file header


   file << "% Flood Neural Network. Genetic Algorithm Object." << std::endl;

   file << "PopulationSize:" << std::endl
        << populationSize << std::endl
        << "NumberOfVariables:" << std::endl
        << numberOfVariables  << std::endl;

   // Training operators

   // Fitness assingment method

   file << "FitnessAssignmentMethod:" << std::endl;

   if(fitnessAssignmentMethod == LinearRanking)
   {
      file << "LinearRanking" << std::endl;
   }
   else if(fitnessAssignmentMethod == NonLinearRanking)
   {
      file << "NonLinearRanking" << std::endl;
   }

   // Selection method

   file << "SelectionMethod:" << std::endl;

   if(selectionMethod == RouletteWheel)
   {
      file << "RouletteWheel" << std::endl;
   }
   else if(selectionMethod == StochasticUniversalSampling)
   {
      file << "StochasticUniversalSampling" << std::endl;
   }

   // Recombination method

   file << "RecombinationMethod:" << std::endl;

   if(recombinationMethod == Line)
   {
      file << "Line" << std::endl;
   }
   else if(recombinationMethod == Intermediate)
   {
      file << "Intermediate" << std::endl;
   }

   // Mutation method

   file << "MutationMethod:" << std::endl;

   if(mutationMethod == Normal)
   {
      file << "Normal" << std::endl;
   }
   else if(mutationMethod == Uniform)
   {
      file << "Uniform" << std::endl;
   }

   // Training parameters

   file << "SelectivePressure:" << std::endl
        << selectivePressure << std::endl
        << "RecombinationSize:" << std::endl
        << recombinationSize << std::endl
        << "MutationRate:" << std::endl
        << mutationRate << std::endl
        << "MutationRange: " << std::endl
        << mutationRange << std::endl;

   // Stopping criteria

   file << "evaluationGoal: " << std::endl
        << evaluationGoal << std::endl
        << "MaximumTime: " << std::endl
        << maximumTime << std::endl
        << "MaximumNumberOfGenerations: " << std::endl
        << maximumNumberOfGenerations << std::endl;

   // User stuff

   file << "ShowPeriod: " << std::endl
        << showPeriod << std::endl;

   Vector<double> individual(numberOfVariables, 0.0);

   file << "Population:" << std::endl;

   for(int i = 0; i < populationSize; i++)
   {
      individual = getIndividual(i);

      file << "Individual" << i << ":" << std::endl; 

      for(int j = 0; j < numberOfVariables; j++)
      {
         file << individual[j] << " ";
      }

      file << std::endl;
   }

   file.close();
}


// void load(char*) method

/// This method loads a genetic algorithm object from a data file. 
/// Please mind about the file format, wich is specified in the User's Guide. 
///
/// Training operators:
/// <ul>
/// <li> Fitness assignment method.
/// <li> Selection method.
/// <li> Recombination method.
/// <li> Mutation method.
/// </ul>
///
/// Training parameters:
/// <ul>
/// <li> Population size.
/// <li> Selective pressure.
/// <li> Recombination size.
/// <li> Mutation rate.
/// <li> Mutation range.
/// </ul>
///
/// Stopping criteria:
/// <ul> 
/// <li> Performance goal.
/// <li> Maximum training time.
/// <li> Maximum number of iterations.
/// </ul> 
///  
/// User stuff: 
/// <ul>
/// <li> Iterations between showing progress.
/// </ul>
///
/// @param filename: Filename.
///
/// @see save(char*).

void GeneticAlgorithm::load(char* filename)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   // File

   std::fstream file;

   file.open(filename, std::ios::in);

   if(!file.is_open())
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void load(char*) method." << std::endl
                << "Cannot open genetic algorithm object data file."  << std::endl;

      exit(1);
   }
   else
   {
      std::cout << std::endl
                << "Loading genetic algorithm object from data file..."  << std::endl;
   }

   // Load new number of individuals and new number of free parameters form
   // file

   int newPopulationSize = 0;
   int newNumberOfVariables = 0;

   std::string word;

   // Training parameters

   // Population size

   while(word != "PopulationSize:")
   {
      file >> word;
   }

   file >> newPopulationSize;

   if(newPopulationSize != populationSize)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void load(char*) method." << std::endl
                << "New population size is not equal to population size." << std::endl
                << std::endl;

      exit(1);
   }

   // Number of free parameters

   file >> word;

   file >> newNumberOfVariables;

   if(newNumberOfVariables != numberOfVariables)
   {
      std::cout << std::endl
                << "Error: GeneticAlgorithm class. void load(char*) method." << std::endl
                << "New number of free parameters is not equal to number of free parameters."
                << std::endl << std::endl;

      exit(1);
   }


   // Training operators

   // Fitness assingment method

   file >> word;

   file >> word;

   if(word == "LinearRanking")
   {
      fitnessAssignmentMethod = LinearRanking;
   }
   else if(word == "NonLinearRanking")
   {
      fitnessAssignmentMethod = NonLinearRanking;
   }
 
   // Selection method
 
   file >> word;

   file >> word;

   if(word == "RouletteWheel")
   {
      selectionMethod = RouletteWheel;
   }
   else if(word == "StochasticUniversalSampling")
   {
      selectionMethod = StochasticUniversalSampling;
   } 

   // Recombination method

   file >> word;

   file >> word;

   if(word == "Line")
   {
      recombinationMethod = Line;
   }
   else if(word == "Intermediate")
   {
      recombinationMethod = Intermediate;
   } 

   // Mutation method

   file >> word;

   file >> word;

   if(word == "Normal")
   {
      mutationMethod = Normal;
   }
   else if(word == "Uniform")
   {
      mutationMethod = Uniform;
   } 

   // Training parameters

   // Selective pressure

   file >> word;

   file >> selectivePressure;

   // Recombination size

   file >> word;

   file >> recombinationSize;

   // Mutation rate

   file >> word;

   file >> mutationRate;

   // Mutation range
 
   file >> word;

   file >> mutationRange;

   // Stopping criteria: 

   // Evaluation goal

   file >> word;

   file >> evaluationGoal;

   // Maximum time

   file >> word;

   file >> maximumTime;
   
   // Maximum number of iterations

   file >> word;

   file >> maximumNumberOfGenerations;

   // User stuff: 

   // Iterations between showing progress

   file >> word;

   file >> showPeriod;

   // Population

   file >> word;

   for (int i = 0; i < populationSize; i++)
   {
      file >> word;

      for (int j = 0; j < numberOfVariables; j++)
      {
         file >> population[i][j];
      }
   }

   // Close file

   file.close();
}


// void saveTrainingHistory(char*) method

/// This method saves the training history to a data file:
///
/// <ol>
/// <li> Iteration.
/// <li> Mean performance.
/// <li> Standard deviation of performance.
/// <li> Best performance ever.
/// </ol>
///
/// @param filename: Filename.

void GeneticAlgorithm::saveOptimizationHistory(char* filename)
{
   int numberOfVariables = objectiveFunction->getNumberOfVariables();

   int numberOfIterations = meanEvaluationHistory.getSize();

   std::fstream file; 

   file.open(filename, std::ios::out);

   if(!file.is_open())
   {
      std::cout << std::endl 
                << "Error: GeneticAlgorithm class. "
                << "void saveTrainingHistory(char*) method." << std::endl
                << "Cannot open training history data file." << std::endl
                << std::endl;

              exit(1);
   }
   else
   {
      std::cout << std::endl 
                << "Saving training history to data file..." << std::endl;
   }

   // Write file header

   file << "% Flood Neural Network. Genetic Algorithm Training History." << std::endl
        << "% 1 - Iteration." << std::endl
        << "% 2 - Standard Deviation of Performance." << std::endl
        << "% 3 - Best Performance Ever." << std::endl;

   // Write file data


   for (int iteration = 0; iteration < numberOfIterations; iteration++)
   {
      file << iteration << " "
           << meanEvaluationHistory[iteration] << " "
           << standardDeviationEvaluationHistory[iteration] << " "
           << bestEvaluationHistory[iteration] << std::endl;
   }

   file << std::endl;

   file.close();
}

}


// Purple: An Open Source Optimization C++ Library.
// Copyright (C) 2005 Roberto Lopez 
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

---