evaluator_proxy.h

Go to the documentation of this file.

 
#if !defined(ULTRA_EVALUATOR_PROXY_H)
#define      ULTRA_EVALUATOR_PROXY_H
 
#include "kernel/cache.h"
#include "kernel/evaluator.h"
 
#include "utility/log.h"
 
namespace ultra
{
/// internal cache that stores fitness values keyed by individual signatures.
/// This avoids repeated evaluation of semantically equivalent individuals and
/// allows expensive evaluators to be reused efficiently.
///
/// The proxy preserves the semantics of the underlying evaluator while
/// extending its capabilities with:
/// - memoisation of fitness values;
/// - optional fast (approximate) evaluation;
/// - optional persistence of both evaluator state and cache contents.
///
/// The cache is logically mutable: cache updates do not alter the observable
/// behaviour of the evaluator. For this reason, most member functions are
/// `const`.
///
template<Evaluator E>
class evaluator_proxy
{
public:
  evaluator_proxy(E, bitwidth);
 
  // Serialization.
  bool load(std::istream &);
  bool save(std::ostream &) const;
 
  bool load_cache(std::istream &) const;
  bool save_cache(std::ostream &) const;
 
  void clear() const noexcept;
  void clear(const hash_t &) const;
 
  [[nodiscard]] evaluator_fitness_t<E> operator()(
    const evaluator_individual_t<E> &) const;
 
  [[nodiscard]] evaluator_fitness_t<E> fast(
    const evaluator_individual_t<E> &) const;
 
  bool set_parallel_evaluation(unsigned, std::size_t = 0);
 
  [[nodiscard]] const E &core() const noexcept;
 
private:
  E eva_;  // wrapped evaluator
 
  // Cache storing fitness values indexed by individual signatures.
  mutable cache<evaluator_fitness_t<E>> cache_;
};
 
#include "kernel/evaluator_proxy.tcc"
 
}  // namespace ultra
 
#endif  // include guard