decision_vector.h

Go to the documentation of this file.

 
#if !defined(ULTRA_DECISION_VECTOR_H)
#define      ULTRA_DECISION_VECTOR_H
 
#include "kernel/individual.h"
 
#include <concepts>
#include <cstddef>
#include <utility>
#include <vector>
 
namespace ultra
{

enum class dv_param_kind : unsigned char { real, integer };

template<class Coord>
struct decision_vector
{
  struct coordinate
  {
    Coord coord;         
    dv_param_kind kind;  
  };
 
  decision_vector() = default;
  decision_vector(std::vector<double> vs, std::vector<coordinate> cs)
    : values(std::move(vs)), coords(std::move(cs))
  {}
 
  std::vector<double> values {};
  std::vector<coordinate> coords {};
 
  [[nodiscard]] bool empty() const noexcept { return values.empty(); }
  [[nodiscard]] std::size_t size() const noexcept { return values.size(); }
 
  [[nodiscard]] bool is_valid() const noexcept
  {
    return values.size() == coords.size();
  }
};

template<class DV>
concept DecisionVector = requires(DV dv, const DV cdv)
{
  typename DV::coordinate;
 
  { dv.values } -> std::same_as<std::vector<double> &>;
  { cdv.values } -> std::same_as<const std::vector<double> &>;
 
  { dv.coords } -> std::same_as<std::vector<typename DV::coordinate> &>;
  { cdv.coords } -> std::same_as<const std::vector<typename DV::coordinate> &>;
 
  { cdv.empty() } -> std::convertible_to<bool>;
  { cdv.size() } -> std::convertible_to<std::size_t>;
};

template<class T>
concept DecisionVectorExtractable = requires(const T &t)
{
  { extract_decision_vector(t) } -> DecisionVector;
};

template<class I> using decision_vector_t =
  std::remove_cvref_t<
    decltype(extract_decision_vector(std::declval<const I &>()))>;

template<class I>
concept NumericalOptimisable =
  Individual<I>
  && std::copy_constructible<I>
  && DecisionVectorExtractable<I>
  && requires(I &ind, const decision_vector_t<I> &dv)
     {
       ind.apply_decision_vector(dv);
     };
 
}  // namespace ultra
 
#endif  // include guard