Chromosome.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 CHROMOSOME_H__
#define CHROMOSOME_H__
 
#include <cassert>
#include <cstdint>
 
#include "BitVector.h"
#include "Genome.h"
 
namespace panga {
 
class RandomWrapper;
 
class Chromosome : public BitVector {
 public:
  explicit Chromosome(const Genome& genome);
  Chromosome(const Chromosome& rhs) = delete;
  Chromosome(Chromosome&& rhs) = default;
  Chromosome& operator=(const Chromosome& rhs) = delete;
  ~Chromosome() = default;
 
  const Genome& GetGenome() const;
 
  void Randomize(RandomWrapper* random);
 
  template <typename IntegerType = uint64_t, bool use_gray_encoding = true>
  IntegerType DecodeIntegerGene(
      size_t gene_index, IntegerType min = 0,
      IntegerType max = std::numeric_limits<IntegerType>::max()) const {
    if (min == max) {
      return min;
    }
 
    const size_t gene_bit_index = genome_.GetGeneStartBitIndex(gene_index);
    const size_t gene_width = genome_.GetGeneBitWitdh(gene_index);
    assert(sizeof(IntegerType) * CHAR_BIT >= gene_width);
 
    auto value = GetInt<IntegerType>(gene_bit_index, gene_width);
    if (use_gray_encoding) {
      value = DecodeGray<IntegerType>(value);
    }
 
    // Clamp into range.
    return (value % (max - min)) + min;
  }
 
  template <typename IntegerType = uint64_t, bool use_gray_encoding = true>
  void EncodeIntegerGene(size_t gene_index, IntegerType value) {
    const size_t gene_bit_index = genome_.GetGeneStartBitIndex(gene_index);
    const size_t gene_width = genome_.GetGeneBitWitdh(gene_index);
    assert(sizeof(IntegerType) * CHAR_BIT >= gene_width);
 
    if (use_gray_encoding) {
      value = EncodeGray<IntegerType>(value);
    }
    SetInt<IntegerType>(value, gene_bit_index, gene_width);
  }
 
  template <typename FloatType = double, bool use_gray_encoding = true>
  FloatType DecodeFloatGene(size_t gene_index, FloatType min,
                            FloatType max) const {
    const uint64_t int_value =
        DecodeIntegerGene<uint64_t, use_gray_encoding>(gene_index);
    const size_t gene_width = genome_.GetGeneBitWitdh(gene_index);
    return DecodeFloat<FloatType, uint64_t>(int_value, gene_width, min, max);
  }
 
  template <typename FloatType = double, bool use_gray_encoding = true>
  void EncodeFloatGene(size_t gene_index, FloatType value, FloatType min,
                       FloatType max) {
    const size_t gene_width = genome_.GetGeneBitWitdh(gene_index);
    const uint64_t int_value =
        EncodeFloat<FloatType, uint64_t>(value, gene_width, min, max);
    EncodeIntegerGene<uint64_t, use_gray_encoding>(gene_index, int_value);
  }
 
  bool DecodeBooleanGene(size_t gene_index) const;
 
  void EncodeBooleanGene(size_t gene_index, bool value);
 
  std::byte* GetRawGene(size_t gene_index, size_t* gene_bit_width);
 
  template <typename IntegerType = uint64_t>
  static IntegerType DecodeGray(IntegerType gray_value) {
    IntegerType binary_value = gray_value;
    while (gray_value >>= 1) {
      binary_value ^= gray_value;
    }
    return binary_value;
  }
 
  template <typename IntegerType = uint64_t>
  static IntegerType EncodeGray(IntegerType binary_value) {
    return binary_value ^ (binary_value >> 1);
  }
 
  template <typename FloatType = double, typename IntegerType = uint64_t>
  static FloatType DecodeFloat(IntegerType int_value, size_t bit_width,
                               FloatType min, FloatType max) {
    constexpr size_t bits_per_byte = 8;
    const IntegerType local_max =
        std::numeric_limits<IntegerType>::max() >>
        (sizeof(IntegerType) * bits_per_byte - bit_width);
    const FloatType factor =
        static_cast<FloatType>(int_value) / static_cast<FloatType>(local_max);
    return factor * (max - min) + min;
  }
 
  template <typename FloatType = double, typename IntegerType = uint64_t>
  static IntegerType EncodeFloat(FloatType float_value, size_t bit_width,
                                 FloatType min, FloatType max) {
    constexpr size_t bits_per_byte = 8;
    const IntegerType local_max =
        std::numeric_limits<IntegerType>::max() >>
        (sizeof(IntegerType) * bits_per_byte - bit_width);
    const FloatType factor = (float_value - min) / (max - min);
    return factor > 1.0 ? local_max
                        : static_cast<IntegerType>(factor * local_max);
  }
 
  static void UniformCrossover(const Chromosome& parent1,
                               const Chromosome& parent2, Chromosome* offspring,
                               RandomWrapper* random,
                               bool ignore_gene_boundaries = true);
 
  static void KPointCrossover(size_t k, const Chromosome& parent1,
                              const Chromosome& parent2, Chromosome* offspring,
                              RandomWrapper* random,
                              bool ignore_gene_boundaries = true);
 
  static void FlipMutator(Chromosome* chromosome, double mutation_percentage,
                          RandomWrapper* random);
 
 private:
  const Genome& genome_;
};
 
}  // namespace panga
 
#endif  // CHROMOSOME_H__