StaircaseFunction.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_STEP_FUNCTION_H
#define GRAIL_STEP_FUNCTION_H
 
#include "Curve.hh"
 
namespace grail
{
namespace evaluator
{
    struct StepData
    {
        float value = 0.0f;
        float startPoint = 0.0f;
        bool inclusiveStartPoint = false;
    };
 
    template <typename ContextType>
    class StaircaseFunction final : public Curve<ContextType>
    {
    public:
        StaircaseFunction(std::shared_ptr<Evaluator<ContextType>> childEvaluator,
                          const std::vector<StepData>& data)
            : Curve<ContextType>{childEvaluator}, data{data}
        {
            #ifndef NDEBUG
            assert(data.size() >= 1);
            float previousX = data[0].startPoint;
            for(size_t i = 1; i < data.size(); ++i)
            {
                assert(previousX < data[i].startPoint);
                previousX = data[i].startPoint;
            }
            #endif //NDEBUG
        }
 
        virtual float Sample(float argument) const override final
        {
            for(std::size_t i = data.size() - 1; i > 0; --i)
            {
                if(argument > data[i].startPoint || (argument == data[i].startPoint && data[i].inclusiveStartPoint))
                {
                    return data[i].value;
                }
            }
            return data[0].value;
        }
 
        std::vector<StepData>& GetData() { return data; }
        const std::vector<StepData>& GetData() const { return data; }
 
        virtual data::EvaluatorType GetEvaluatorType() const override final { return data::EvaluatorType::CURVE_STAIRCASE; }
 
    private:
        std::vector<StepData> data{};
    };
}
}
#endif // GRAIL_STEP_FUNCTION_H