fitness.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_FITNESS_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_FITNESS_TCC)
#define      ULTRA_FITNESS_TCC

inline constexpr fitnd::fitnd(std::initializer_list<double> l) : vect_(l)
{
}
 
template<Fitness F>
[[nodiscard]] constexpr F lowest() noexcept
{
  return std::numeric_limits<F>::lowest();
}
 
template<std::integral F>
[[nodiscard]] bool isfinite(F) noexcept
{
  return true;
}
 
template<std::floating_point F>
[[nodiscard]] bool isfinite(F f)
{
  return std::isfinite(f);
}

template<MultiDimFitness F>
[[nodiscard]] bool isfinite(const F &f)
{
  return std::ranges::all_of(f, [](auto v) { return isfinite(v); });
}

template<Fitness F>
requires std::is_arithmetic_v<F>
[[nodiscard]] bool dominating(const F &lhs, const F &rhs)
{
  return rhs < lhs;
}
 
template<MultiDimFitness F>
[[nodiscard]] bool dominating(const F &lhs, const F &rhs)
{
  Expects(std::ranges::size(lhs) == std::ranges::size(rhs));
 
  bool one_better(false);
 
  for (auto [l, r] : std::views::zip(lhs, rhs))
    if (l > r)
      one_better = true;
    else if (l < r)
      return false;
 
  return one_better;
}
 
template<MultiDimFitness F>
[[nodiscard]] bool almost_equal(const F &lhs, const F &rhs)
{
  return std::ranges::equal(
    lhs, rhs,
    [](auto v1, auto v2) { return almost_equal(v1, v2); });
}

template<Fitness F>
requires std::is_arithmetic_v<F>
[[nodiscard]] double distance(F f1, F f2)
{
  if constexpr (std::floating_point<F>)
    return std::fabs(f1 - f2);
  else
  {
    // Compute the absolute difference in the corresponding unsigned type.
    // This avoids signed overflow, including the lowest()/max() case.
    // Conversion from signed to unsigned is well-defined modulo 2^N and the
    // subtraction is then performed in the unsigned domain.
    using U = std::make_unsigned_t<F>;
 
    return static_cast<double>(f1 >= f2 ? U(f1) - U(f2) : U(f2) - U(f1));
  }
}
 
template<MultiDimFitness F>
[[nodiscard]] double distance(const F &f1, const F &f2)
{
  Expects(std::ranges::size(f1) == std::ranges::size(f2));
 
  return std::transform_reduce(
    std::ranges::begin(f1), std::ranges::end(f1), std::ranges::begin(f2), 0.0,
    std::plus{}, [](auto a, auto b) { return ultra::distance(a, b); });
}

template<Fitness F>
requires std::floating_point<F>
[[nodiscard]] bool save(std::ostream &out, F f)
{
  save_float_to_stream(out, f);
  out << '\n';
 
  return out.good();
}
 
template<std::integral F>
[[nodiscard]] bool save(std::ostream &out, F f)
{
  out << f << '\n';
 
  return out.good();
}
 
template<MultiDimFitness F>
requires std::floating_point<std::ranges::range_value_t<F>>
[[nodiscard]] bool save(std::ostream &out, const F &f)
{
  out << std::ranges::size(f);
 
  for (auto v : f)
  {
    out << ' ';
    save_float_to_stream(out, v);
  }
 
  return out.good();
}

template<std::floating_point F>
bool load(std::istream &in, F *f)
{
  return load_float_from_stream(in, f);
}
 
template<std::integral F>
bool load(std::istream &in, F *f)
{
  return in >> *f;
}
 
#endif  // include guard