gp/individual.h

Go to the documentation of this file.

 
#if !defined(ULTRA_GP_INDIVIDUAL_H)
#define      ULTRA_GP_INDIVIDUAL_H
 
#include "kernel/individual.h"
#include "kernel/decision_vector.h"
#include "kernel/problem.h"
#include "kernel/random.h"
#include "kernel/gp/gene.h"
#include "utility/matrix.h"
#include "utility/misc.h"
 
#include <iosfwd>
#include <iterator>
#include <set>
 
namespace ultra::gp
{
 
namespace internal
{
  class crossover_engine;
}
 
#include "kernel/gp/individual_exon_view.tcc"

struct decision_coordinate
{
  locus loc;
  std::size_t arg_index;
};

using decision_vector = ultra::decision_vector<decision_coordinate>;
 


///
class individual final : public ultra::individual
{
public:
  // ---- Constructors ----
  individual() = default;
  explicit individual(const problem &);
  explicit individual(const std::vector<gene> &);
 
  // ---- Capacity ----
  [[nodiscard]] symbol::category_t categories() const noexcept;
  [[nodiscard]] bool empty() const noexcept;
  [[nodiscard]] locus::index_t size() const noexcept;
 
  // ---- Element access ----
  [[nodiscard]] const gene &operator[](const locus &) const noexcept;
  [[nodiscard]] locus start() const noexcept;
 
  // ---- Recombination operators ----
  enum crossover_t {one_point, two_points, tree, uniform, dependency,
                    NUM_CROSSOVERS};
  unsigned mutation(const problem &, double = 1.0);
 
  void apply_decision_vector(const decision_vector &);
 
  [[nodiscard]] crossover_t active_crossover_type() const noexcept;
 
  [[nodiscard]] matrix<unsigned> analyse_importance(
    const std::vector<locus> &) const;
 
  // ---- Iterators ----
  using const_exon_iterator = internal::basic_exon_iterator<true>;
  using exon_iterator = internal::basic_exon_iterator<false>;
 
  [[nodiscard]] const_exon_view cexons() const;
 
  [[nodiscard]] auto begin() const noexcept { return genome_.cbegin(); }
  [[nodiscard]] auto end() const noexcept { return genome_.cend(); }
 
  // ---- Misc ----
  [[nodiscard]] bool operator==(const individual &) const noexcept;
  [[nodiscard]] bool is_valid() const;
 
private:
  template<bool> friend class internal::basic_exon_iterator;
  friend class internal::crossover_engine;
 
  // ---- Private member functions ----
  [[nodiscard]] exon_view exons();
  [[nodiscard]] hash_t hash() const override;
  void pack(const locus &, hash_sink &) const;
 
  // ---- Serialization ----
  [[nodiscard]] bool load_impl(std::istream &, const symbol_set &) override;
  [[nodiscard]] bool save_impl(std::ostream &) const override;
 
  void print_impl(std::ostream &, out::print_format_t) const override;
 
  // ---- Private data members ----
  // This is the genome: the entire collection of genes.
  matrix<gene> genome_ {};
 
  // Crossover operator used to create this individual. Initially this is set
  // to a random type.
  crossover_t active_crossover_type_ {random::sup(NUM_CROSSOVERS)};
};
 
 
// ---- Non-member functions ----
[[nodiscard]] unsigned active_slots(const individual &);
[[nodiscard]] individual crossover(const problem &,
                                   const individual &, const individual &);
[[nodiscard]] unsigned distance(const individual &, const individual &);
[[nodiscard]] decision_vector extract_decision_vector(const individual &);
[[nodiscard]] locus random_locus(const individual &);
 
}  // namespace ultra::gp
 
#include "kernel/individual_format.h"
 
#endif  // include guard