GeneticAlgorithm.h

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Taylor Woll and panga contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for
// full license information.
//-------------------------------------------------------------------------------------------------------
 
#ifndef GENETICALGORITHM_H__
#define GENETICALGORITHM_H__
 
#include <vector>
 
#include "Genome.h"
#include "Population.h"
#include "RandomWrapper.h"
 
namespace panga {
 
class Individual;
class BitVector;
 
using FitnessFunction = double (*)(Individual*, void*);
 
class GeneticAlgorithm {
 public:
  enum class CrossoverType : uint8_t {
    OnePoint = 1,
 
    TwoPoint,
 
    KPoint,
 
    Uniform
  };
 
  enum class MutatorType : uint8_t {
    Flip = 1
  };
 
  enum class SelectorType : uint8_t {
    Rank = 1,
 
    Uniform,
 
    RouletteWheel,
 
    Tournament
  };
 
  enum class MutationRateSchedule : uint8_t {
    Constant = 1,
 
    Deterministic,
 
    SelfAdaptive,
 
    Proportional
  };
 
  GeneticAlgorithm();
  GeneticAlgorithm(const GeneticAlgorithm& rhs) = delete;
  GeneticAlgorithm& operator=(const GeneticAlgorithm& rhs) = delete;
  ~GeneticAlgorithm() = default;
 
  Genome& GetGenome();
 
  void SetCrossoverIgnoreGeneBoundaries(bool crossover_ignore_gene_boundaries);
  bool GetCrossoverIgnoreGeneBoundaries() const;
 
  void SetAllowSameParentCouples(bool allow_same_parent_couples);
  bool GetAllowSameParentCouples() const;
 
  void SetTournamentSize(size_t tournament_size);
  size_t GetTournamentSize() const;
 
  void SetKPointCrossoverPointCount(size_t k_point_crossover_point_count);
  size_t GetKPointCrossoverPointCount() const;
 
  void SetSelfAdaptiveMutationDiversityFloor(
      double self_adaptive_mutation_diversity_floor);
  double GetSelfAdaptiveMutationDiversityFloor() const;
 
  void SetSelfAdaptiveMutationAggressiveRate(
      double self_adaptive_mutation_aggressive_rate);
  double GetSelfAdaptiveMutationAggressiveRate() const;
 
  void SetProportionalMutationBitCount(size_t proportional_mutation_bit_count);
  size_t GetProportionalMutationBitCount() const;
 
  void SetTotalGenerations(size_t total_generations);
  size_t GetTotalGenerations() const;
 
  void SetMutationRate(double mutation_rate);
  double GetMutationRate() const;
 
  void SetCrossoverRate(double crossover_rate);
  double GetCrossoverRate() const;
 
  void SetCrossoverType(CrossoverType crossover_type);
  CrossoverType GetCrossoverType() const;
 
  void SetSelectorType(SelectorType selector_type);
  SelectorType GetSelectorType() const;
 
  void SetEliteCount(size_t elite_count);
  size_t GetEliteCount() const;
 
  void SetMutatedEliteCount(size_t mutated_elite_count);
  size_t GetMutatedEliteCount() const;
 
  void SetMutatedEliteMutationRate(double mutated_elite_mutation_rate);
  double GetMutatedEliteMutationRate() const;
 
  void SetMutationRateSchedule(MutationRateSchedule mutation_rate_schedule);
  MutationRateSchedule GetMutationRateSchedule() const;
 
  void SetMutatorType(MutatorType mutator_type);
  MutatorType GetMutatorType() const;
 
  void SetUserData(void* user_data);
  void* GetUserData() const;
 
  void SetFitnessFunction(FitnessFunction fitness_function);
  FitnessFunction GetFitnessFunction() const;
 
  void SetPopulationSize(size_t population_size);
  size_t GetPopulationSize() const;
 
  size_t GetCurrentGeneration() const;
 
  const Population& GetPopulation() const;
 
  void Initialize();
 
  void SetInitialPopulation(const std::vector<BitVector>& initial_population);
 
  void Step();
 
  void Run();
 
 protected:
  void Crossover(const Individual& parent1, const Individual& parent2,
                 Individual* offspring);
 
  void Mutate(Individual* individual, double mutation_percentage);
 
  double GetCurrentMutationRate();
 
  void InitializeSelector(Population* population);
 
  std::pair<const Individual&, const Individual&> SelectParents(
      const Population& population);
 
  const Individual& SelectOne(const Population& population);
 
  Population& GetCurrentPopulation();
 
  Population& GetLastGenerationPopulation();
 
 private:
  static constexpr double DefaultMutationRate = 0.0005;
  static constexpr double DefaultCrossoverRate = 0.9;
  static constexpr double DefaultMutatedEliteMutationRate = 0.33;
  static constexpr double DefaultSelfAdaptiveMutationDiversityFloor = 0.0002;
  static constexpr double DefaultSelfAdaptiveMutationAggressiveRate = 0.1;
  static constexpr size_t DefaultTournamentSize = 2;
  static constexpr size_t DefaultKPointCrossoverCount = 3;
  static constexpr size_t DefaultProportionalMutationBitCount = 1;
 
  Genome genome_;
  std::vector<Population> populations_;
  RandomWrapper random_;
 
  void* user_data_ = nullptr;
  FitnessFunction fitness_function_ = nullptr;
 
  size_t population_size_ = 0;
  size_t total_generations_ = 0;
  size_t current_generation_ = 0;
 
  size_t elite_count_ = 0;
  size_t mutated_elite_count_ = 0;
 
  double mutation_rate_ = DefaultMutationRate;
  double crossover_rate_ = DefaultCrossoverRate;
  double mutated_elite_mutation_rate_ = DefaultMutatedEliteMutationRate;
 
  size_t tournament_size_ = DefaultTournamentSize;
  size_t k_point_crossover_point_count_ = DefaultKPointCrossoverCount;
  double self_adaptive_mutation_diversity_floor_ =
      DefaultSelfAdaptiveMutationDiversityFloor;
  double self_adaptive_mutation_aggressive_rate_ =
      DefaultSelfAdaptiveMutationAggressiveRate;
  size_t proportional_mutation_bit_count_ = DefaultProportionalMutationBitCount;
 
  CrossoverType crossover_type_ = CrossoverType::Uniform;
  MutatorType mutator_type_ = MutatorType::Flip;
  SelectorType selector_type_ = SelectorType::Tournament;
  MutationRateSchedule mutation_rate_schedule_ = MutationRateSchedule::Constant;
 
  bool crossover_ignore_gene_boundaries_ = true;
  bool allow_same_parent_couples_ = true;
  bool is_initial_population_evaluated_ = false;
};
 
}  // namespace panga
 
#endif  // GENETICALGORITHM_H__