Evaluator.hh

#ifndef GRAIL_EVALUATOR_H
#define GRAIL_EVALUATOR_H
 
#include "Consideration.hh"
#include "Curves/Curve.hh"
#include "IEvaluator.hh"
 
#include <vector>
#include <cassert>
#include <limits>
#include <memory>
 
namespace grail
{
    namespace utility
    {
        template <typename ContextType>
        class Evaluator final : public IEvaluator<ContextType>
        {
        public:
            using CurveDataPair = std::pair<std::shared_ptr<Consideration<ContextType>>, std::shared_ptr<curves::Curve>>;
            Evaluator(WeightEvaluationMethod evaluationMethod, const std::vector<CurveDataPair>& curveData)
                : curveData{ curveData }, method{ evaluationMethod }
            {
            }
 
            Evaluator(const Evaluator<ContextType>&) = default;
            Evaluator(Evaluator<ContextType>&&) = default;
 
            virtual ~Evaluator() = default;
 
            Evaluator& operator = (const Evaluator<ContextType>&) = default;
            Evaluator& operator = (Evaluator<ContextType>&&) = default;
 
            float EvaluateWeight(const ContextType& object) const override
            {
                switch (method)
                {
                case WeightEvaluationMethod::MULTIPLY:
                    return EvaluateByMultiplication(object);
 
                case WeightEvaluationMethod::AVERAGE:
                    return EvaluateByAverage(object);
 
                case WeightEvaluationMethod::MAX:
                    return EvaluateByMax(object);
 
                case WeightEvaluationMethod::MIN:
                    return EvaluateByMin(object);
 
                case WeightEvaluationMethod::ADD:
                    return EvaluateByAddition(object);
                default:
                    return 0;
                }
            }
 
            int EvaluateRank() const override
            {
                int rank = std::numeric_limits<int>::min();
                for (const CurveDataPair& data : curveData)
                {
                    if (data.first->GetRank() > rank)
                        rank = data.first->GetRank();
                }
                return rank;
            }
 
            const std::vector<CurveDataPair>& GetCurveData() const
            {
                return curveData;
            }
 
            WeightEvaluationMethod GetEvaluationMethod() const override
            {
                return method;
            }
 
        protected:
            float EvaluateConsiderations(const std::shared_ptr<Consideration<ContextType>>& consideration, const ContextType& object) const
            {
                return consideration->Evaluate(object);
            }
 
        private:
            std::vector<CurveDataPair> curveData = {};
            WeightEvaluationMethod method{};
 
            float EvaluateByMultiplication(const ContextType& object) const
            {
                float weight = 1;
                for (const CurveDataPair& data : curveData)
                {
                    weight *= data.second->Sample(EvaluateConsiderations(data.first, object));
                }
                return weight;
            }
 
            float EvaluateByAverage(const ContextType& object) const
            {
                float weight = 0;
                for (const CurveDataPair& data : curveData)
                {
                    weight += data.second->Sample(EvaluateConsiderations(data.first, object));
                }
                return curveData.size() > 0 ? weight / curveData.size() : 0;
            }
 
            float EvaluateByAddition(const ContextType& object) const
            {
                float weight = 0;
                for (const CurveDataPair& data : curveData)
                {
                    weight += data.second->Sample(EvaluateConsiderations(data.first, object));
                }
                return weight;
            }
 
            float EvaluateByMax(const ContextType& object) const
            {
                float weight = std::numeric_limits<float>::min();
                for (const CurveDataPair& data : curveData)
                {
                    float current = data.second->Sample(EvaluateConsiderations(data.first, object));
                    if (current > weight)
                        weight = current;
                }
                return weight;
            }
 
            float EvaluateByMin(const ContextType& object) const
            {
                float weight = std::numeric_limits<float>::max();
                for (const CurveDataPair& data : curveData)
                {
                    float current = data.second->Sample(EvaluateConsiderations(data.first, object));
                    if (current < weight)
                        weight = current;
                }
                return weight;
            }
        };
    }
}
#endif  //GRAIL_EVALUATOR_H