fitness.h

Go to the documentation of this file.

 
#if !defined(ULTRA_FITNESS_H)
#define      ULTRA_FITNESS_H
 
#include "utility/assert.h"
#include "utility/misc.h"
 
#include <algorithm>
#include <cmath>
#include <functional>
#include <iterator>
#include <numeric>
#include <ranges>
#include <type_traits>
#include <vector>
 
namespace ultra
{

/// other applications try to minimize it).
/// We chose this convention since it seemed more natural (a greater fitness
/// is a better fitness; achieving a better fitness means to maximize the
/// fitness). The downside is that sometimes we have to manage negative
/// numbers, but for our purposes it's not so bad.
/// Anyway maximization and minimization problems are basically the same: the
/// solution of `max(f(x))` is the same as `-min(-f(x))`. This is usually
/// all you have to remember when dealing with examples/problems expressed
/// in the other notation.
///
/// \remark
/// This intentionally excludes `bool`, since `bool{-1} < bool{0}` is
/// equivalent to `true < false`, which is `false`.
///
template<class F> concept Fitness =
  OrderedArithmeticType<F> && requires { requires F{-1} < F{0}; };

/// container exposing member iterator functions.
template<class F> concept MultiDimFitness =
  std::ranges::sized_range<F> && std::ranges::sized_range<const F>
  && Fitness<std::ranges::range_value_t<F>>;

class with_size
{
public:
  explicit with_size(std::size_t s) : size_(s) {}
  std::size_t operator()() const { return size_; }
 
private:
  std::size_t size_;
};

class fitnd
{
public:
  // Type alias and iterators.
  using value_type = double;
  using values_t = std::vector<value_type>;
  using iterator = values_t::iterator;
  using const_iterator = values_t::const_iterator;
  using difference_type = values_t::difference_type;
 
  constexpr fitnd() = default;
  constexpr fitnd(std::initializer_list<double>);
  fitnd(values_t);
  fitnd(with_size, value_type = std::numeric_limits<value_type>::lowest());
 
  [[nodiscard]] std::size_t size() const noexcept;
  [[nodiscard]] bool empty() const noexcept;
  [[nodiscard]] value_type operator[](std::size_t) const;
  [[nodiscard]] value_type &operator[](std::size_t);
 
  [[nodiscard]] iterator begin() noexcept;
  [[nodiscard]] iterator end() noexcept;
  [[nodiscard]] const_iterator begin() const noexcept;
  [[nodiscard]] const_iterator end() const noexcept;
 
  [[nodiscard]] friend auto operator<=>(const fitnd &, const fitnd &) = default;
 
  fitnd &operator+=(const fitnd &);
  fitnd &operator-=(const fitnd &);
  fitnd &operator*=(const fitnd &);
  fitnd &operator/=(const fitnd &);
 
  fitnd &operator*=(value_type);
  fitnd &operator/=(value_type);
 
  friend bool load(std::istream &, fitnd *);
  friend fitnd combine(const fitnd &, const fitnd &);
 
private:
  values_t vect_ {};
};
 
// ***********************************************************************
// *  Arithmetic operators                                               *
// ***********************************************************************
[[nodiscard]] fitnd operator+(fitnd, const fitnd &);
[[nodiscard]] fitnd operator-(fitnd, const fitnd &);
[[nodiscard]] fitnd operator*(fitnd, const fitnd &);
[[nodiscard]] fitnd operator/(fitnd, const fitnd &);
[[nodiscard]] fitnd operator*(fitnd, fitnd::value_type);
[[nodiscard]] fitnd operator*(fitnd::value_type, fitnd);
[[nodiscard]] fitnd operator/(fitnd, fitnd::value_type);
[[nodiscard]] fitnd operator-(fitnd);
 
// ***********************************************************************
// *  Serialization                                                      *
// ***********************************************************************
[[nodiscard]] bool load(std::istream &, fitnd *);
 
// ***********************************************************************
// *  Other functions                                                    *
// ***********************************************************************
[[nodiscard]] fitnd abs(fitnd);
[[nodiscard]] fitnd sqrt(fitnd);
std::ostream &operator<<(std::ostream &, const fitnd &);
std::istream &operator>>(std::istream &, fitnd &);
 
#include "kernel/fitness.tcc"
 
}  // namespace ultra
 
#endif  // include guard