FunctionalFitness.h

Go to the documentation of this file.

#ifndef FUNCTIONAL_FITNESS_H
#define FUNCTIONAL_FITNESS_H
 
#pragma once
 
#include "core/FitnessFunction.h"
#include <functional>
#include <vector>
#include <cstddef>
#include <utility>
 
namespace galib {
 
    template <typename GeneType = double>
    class FunctionalFitness : public FitnessFunction<GeneType> {
    public:
        using EvalFunc = std::function<double(const std::vector<GeneType>&)>;
 
        using FitnessFunction<GeneType>::getLowerBound;
        using FitnessFunction<GeneType>::getUpperBound;
 
        FunctionalFitness(
            std::size_t dims,
            GeneType lower,
            GeneType upper,
            EvalFunc func
        ) : dimensions_m(dims),
            lower_bounds_m(dims, lower),
            upper_bounds_m(dims, upper),
            evaluator_m(std::move(func)) {}
 
        FunctionalFitness(
            std::size_t dims,
            std::vector<GeneType> lowers,
            std::vector<GeneType> uppers,
            EvalFunc func
        ) : dimensions_m(dims),
            lower_bounds_m(std::move(lowers)),
            upper_bounds_m(std::move(uppers)),
            evaluator_m(std::move(func)) {
            if (lower_bounds_m.size() != dims || upper_bounds_m.size() != dims) {
                throw std::invalid_argument("Bounds vectors must match dimensions size");
            }
        }
 
        [[nodiscard]] double evaluate(const std::vector<GeneType>& phenotype) const override {
            return evaluator_m(phenotype);
        }
 
        [[nodiscard]] std::size_t size() const override {
            return dimensions_m;
        }
 
        [[nodiscard]] GeneType getLowerBound(std::size_t dimension) const override {
            return lower_bounds_m.at(dimension);
        }
 
        [[nodiscard]] GeneType getUpperBound(std::size_t dimension) const override {
            return upper_bounds_m.at(dimension);
        }
 
    private:
        std::size_t dimensions_m;
        std::vector<GeneType> lower_bounds_m;
        std::vector<GeneType> upper_bounds_m;
        EvalFunc evaluator_m;
    };
 
} // namespace galib
 
#endif // FUNCTIONAL_FITNESS_H