fitness.h

Go to the documentation of this file.

 
#if !defined(VITA_FITNESS_H)
#define      VITA_FITNESS_H
 
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
 
#include "utility/small_vector.h"
#include "utility/utility.h"
 
namespace vita
{
 
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_;
};
 
template<class T>
class basic_fitness_t
{
public:
  // Type alias and iterators.
  using values_t = small_vector<T, 1>;
  using value_type = typename values_t::value_type;
  using iterator = typename values_t::iterator;
  using const_iterator = typename values_t::const_iterator;
 
  basic_fitness_t();
  basic_fitness_t(std::initializer_list<T>);
  basic_fitness_t(values_t);
  basic_fitness_t(with_size, T = std::numeric_limits<T>::lowest());
 
  std::size_t size() const;
  T operator[](std::size_t) const;
  T &operator[](std::size_t);
 
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
 
  basic_fitness_t &operator+=(const basic_fitness_t &);
  basic_fitness_t &operator-=(const basic_fitness_t &);
  basic_fitness_t &operator*=(const basic_fitness_t &);
 
  // Serialization.
  bool load(std::istream &);
  bool save(std::ostream &) const;
 
private:
  values_t vect_;
};
 
// ***********************************************************************
// *  Arithmetic operators                                               *
// ***********************************************************************
template<class T> basic_fitness_t<T> operator+(basic_fitness_t<T>,
                                               const basic_fitness_t<T> &);
template<class T> basic_fitness_t<T> operator-(basic_fitness_t<T>,
                                               const basic_fitness_t<T> &);
template<class T> basic_fitness_t<T> operator*(basic_fitness_t<T>,
                                               const basic_fitness_t<T> &);
template<class T> basic_fitness_t<T> operator/(basic_fitness_t<T>, T);
template<class T> basic_fitness_t<T> operator*(basic_fitness_t<T>, T);
 
// ***********************************************************************
// *  Comparison operators                                               *
// ***********************************************************************
template<class T> bool operator==(const basic_fitness_t<T> &,
                                  const basic_fitness_t<T> &);
template<class T> bool operator!=(const basic_fitness_t<T> &,
                                  const basic_fitness_t<T> &);
template<class T> bool operator>(const basic_fitness_t<T> &,
                                 const basic_fitness_t<T> &);
template<class T> bool operator<(const basic_fitness_t<T> &,
                                 const basic_fitness_t<T> &);
template<class T> bool operator>=(const basic_fitness_t<T> &,
                                  const basic_fitness_t<T> &);
template<class T> bool operator<=(const basic_fitness_t<T> &,
                                  const basic_fitness_t<T> &);
 
template<class T> bool almost_equal(const basic_fitness_t<T> &,
                                    const basic_fitness_t<T> &, T = 0.00001);
template<class T> bool dominating(const basic_fitness_t<T> &,
                                  const basic_fitness_t<T> &);
 
// ***********************************************************************
// *  Other functions                                                    *
// ***********************************************************************
template<class T> bool isfinite(const basic_fitness_t<T> &);
template<class T> bool isnan(const basic_fitness_t<T> &);
template<class T> bool isnonnegative(const basic_fitness_t<T> &);
template<class T> bool issmall(const basic_fitness_t<T> &);
 
template<class T> basic_fitness_t<T> abs(basic_fitness_t<T>);
template<class T> basic_fitness_t<T> combine(const basic_fitness_t<T> &,
                                             const basic_fitness_t<T> &);
template<class T> double distance(const basic_fitness_t<T> &,
                                  const basic_fitness_t<T> &);
template<class T> basic_fitness_t<T> round_to(basic_fitness_t<T>);
template<class T> basic_fitness_t<T> sqrt(basic_fitness_t<T>);
 
using fitness_t = basic_fitness_t<double>;
 
#include "kernel/fitness.tcc"
}  // namespace vita
 
#endif  // include guard