EvolutionaryAlgorithm.h

/****************************************************************************************************************/
/*                                                                                                              */
/*   Flood: An Open Source Neural Networks C++ Library                                                          */
/*   www.cimne.com/flood                                                                                        */
/*                                                                                                              */
/*   E V O L U T I O N A R Y   A L G O R I T H M   C L A S S   H E A D E R                                      */
/*                                                                                                              */
/*   Roberto Lopez                                                                                              */
/*   International Center for Numerical Methods in Engineering (CIMNE)                                          */
/*   Technical University of Catalonia (UPC)                                                                    */
/*   Barcelona, Spain                                                                                           */
/*   E-mail: rlopez@cimne.upc.edu                                                                               */
/*                                                                                                              */
/****************************************************************************************************************/


#ifndef __EVOLUTIONARYALGORITHM_H__
#define __EVOLUTIONARYALGORITHM_H__


#include "TrainingAlgorithm.h"
#include "../ObjectiveFunctional/ObjectiveFunctional.h"

namespace Flood
{
 

class EvolutionaryAlgorithm : public TrainingAlgorithm
{

public:

   // ENUMERATIONS


   enum FitnessAssignmentMethod{LinearRanking};


   enum SelectionMethod{RouletteWheel, StochasticUniversalSampling};


   enum RecombinationMethod{Line, Intermediate};


   enum MutationMethod{Normal, Uniform};
    // GENERAL CONSTRUCTOR

   explicit EvolutionaryAlgorithm(ObjectiveFunctional*);


   // DEFAULT CONSTRUCTOR

   explicit EvolutionaryAlgorithm(void);


   // DESTRUCTOR

   virtual ~EvolutionaryAlgorithm(void);


   // METHODS

   // Get methods

   // Population methods

   int get_population_size(void);

   Matrix<double>& get_population(void);

   // Training operators

   FitnessAssignmentMethod& get_fitness_assignment_method(void);
   std::string get_fitness_assignment_method_name(void);

   SelectionMethod& get_selection_method(void);
   std::string get_selection_method_name(void);

   RecombinationMethod& get_recombination_method(void);
   std::string get_recombination_method_name(void);

   MutationMethod& get_mutation_method(void);
   std::string get_mutation_method_name(void);

   // Population values

   Vector<double>& get_evaluation(void);
   Vector<double>& get_fitness(void);
   Vector<bool>& get_selection(void);

   bool get_elitism(void);
   double get_selective_pressure(void);

   double get_recombination_size(void);
   double get_mutation_rate(void);
   double get_mutation_range(void);    double get_maximum_generations_number(void);
   double get_mean_evaluation_goal(void);
   double get_standard_deviation_evaluation_goal(void);

   bool get_reserve_population_history(void);
   bool get_reserve_best_individual_history(void);
   bool get_reserve_mean_norm_history(void);
   bool get_reserve_standard_deviation_norm_history(void);
   bool get_reserve_best_norm_history(void);

   bool get_reserve_mean_evaluation_history(void);
   bool get_reserve_standard_deviation_evaluation_history(void);
   bool get_reserve_best_evaluation_history(void);

   Vector< Matrix<double> >& get_population_history(void);

   Vector< Vector<double> >& get_best_individual_history(void);

   Vector<double>& get_mean_norm_history(void);
   Vector<double>& get_standard_deviation_norm_history(void);
   Vector<double>& get_best_norm_history(void);

   Vector<double>& get_mean_evaluation_history(void);
   Vector<double>& get_standard_deviation_evaluation_history(void);
   Vector<double>& get_best_evaluation_history(void);

   // Set methods

   void set(void);
   void set(ObjectiveFunctional*);

   void set_default(void);

   void set_fitness_assignment_method(const FitnessAssignmentMethod&);
   void set_fitness_assignment_method(const std::string&);

   void set_selection_method(const SelectionMethod&);
   void set_selection_method(const std::string&);

   void set_recombination_method(const RecombinationMethod&);
   void set_recombination_method(const std::string&);

   void set_mutation_method(const MutationMethod&);
   void set_mutation_method(const std::string&);

   void set_population_size(int);

   void set_population(const Matrix<double>&);

   void set_evaluation(const Vector<double>&);
   void set_fitness(const Vector<double>&);
   void set_selection(const Vector<bool>&);

   void set_elitism(bool);
   void set_selective_pressure(double);
   void set_recombination_size(double);

   void set_mutation_rate(double);
   void set_mutation_range(double);

   void set_maximum_generations_number(int);
   void set_mean_evaluation_goal(double);
   void set_standard_deviation_evaluation_goal(double);

   void set_reserve_population_history(bool);

   void set_reserve_best_individual_history(bool);

   void set_reserve_mean_norm_history(bool);
   void set_reserve_standard_deviation_norm_history(bool);
   void set_reserve_best_norm_history(bool);

   void set_reserve_mean_evaluation_history(bool);
   void set_reserve_standard_deviation_evaluation_history(bool);
   void set_reserve_best_evaluation_history(bool);

   void set_reserve_all_training_history(bool);

   void set_population_history(const Vector< Matrix<double> >&);

   void set_best_individual_history(const Vector< Vector<double> >&);

   void set_mean_norm_history(const Vector<double>&);
   void set_standard_deviation_norm_history(const Vector<double>&);
   void set_best_norm_history(const Vector<double>&);

   void set_mean_evaluation_history(const Vector<double>&);
   void set_standard_deviation_evaluation_history(const Vector<double>&);
   void set_best_evaluation_history(const Vector<double>&);

   // Population methods

   Vector<double> get_individual(int);
   void set_individual(int, const Vector<double>&);

   Vector<double> get_best_individual(void);

   double calculate_mean_evaluation(void);
   double calculate_standard_deviation_evaluation(void);

   // Initialization methods

   void initialize_population(double);

   void initialize_population_uniform(void);
   void initialize_population_uniform(double, double);
   void initialize_population_uniform(const Vector<double>&, const Vector<double>&);
   void initialize_population_uniform(const Matrix<double>&);

   void initialize_population_normal(void);
   void initialize_population_normal(double, double);
   void initialize_population_normal(const Vector<double>&, const Vector<double>&);
   void initialize_population_normal(const Matrix<double>&);
    
   // Population norm methods

   Vector<double> calculate_population_norm(void);

   // Population evaluation methods

   void perform_fitness_assignment(void);
   void perform_selection(void);
   void perform_recombination(void);
   void perform_mutation(void);

   void evolve_population(void);

   void evaluate_population(void);

   // Fitness assignment methods

   void perform_linear_ranking_fitness_assignment(void);

   // Selection methods

   void perform_roulette_wheel_selection(void);
   void perform_stochastic_universal_sampling_selection(void);

   // Recombination methods

   void perform_intermediate_recombination(void);
   void perform_line_recombination(void);

   // Mutation methods

   void perform_normal_mutation(void);
   void perform_uniform_mutation(void);

   // Train methods

   void train(void);
   
   // Training history methods

   void resize_training_history(int);

   std::string get_training_history_XML(bool);

   // Utility methods

   std::string to_XML(bool);
   void load(const char*);


private:

   // MEMBERS


   FitnessAssignmentMethod fitness_assignment_method;


   SelectionMethod selection_method;


   RecombinationMethod recombination_method;


   MutationMethod mutation_method;

   // Population stuff


   Matrix<double> population;


   Vector<double> evaluation;


   Vector<double> fitness;


   Vector<bool> selection;
   
   // Training parameters

   bool elitism;


   double selective_pressure;


   double recombination_size;


   double mutation_rate;


   double mutation_range;

   double mean_evaluation_goal;

   double standard_deviation_evaluation_goal;

   
   int maximum_generations_number;


   bool reserve_population_history;


   bool reserve_best_individual_history;


   bool reserve_mean_norm_history;


   bool reserve_standard_deviation_norm_history;


   bool reserve_best_norm_history;
   

   bool reserve_mean_evaluation_history;


   bool reserve_standard_deviation_evaluation_history;


   bool reserve_best_evaluation_history;


   Vector< Matrix<double> > population_history;


   Vector< Vector<double> > best_individual_history;


   Vector<double> mean_norm_history;


   Vector<double> standard_deviation_norm_history;


   Vector<double> best_norm_history;


   Vector<double> mean_evaluation_history;


   Vector<double> standard_deviation_evaluation_history;


   Vector<double> best_evaluation_history;

   // METHODS

   // Utility methods

   double calculate_random_uniform(double, double);
   double calculate_random_normal(double, double);
};

}

#endif


// Flood: An Open Source Neural Networks C++ Flood.
// Copyright (C) 2005-2010 Roberto Lopez 
//
// This Flood is free software; you can redistribute it and/or
// modify it under the s 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 Flood 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 Flood; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

---