PowerFunction.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_POWER_FUNCTION_H
#define GRAIL_POWER_FUNCTION_H
 
#include <cmath>
#include "Curve.hh"
 
namespace grail
{
namespace evaluator
{
    template <typename ContextType>
    class PowerFunction final : public Curve<ContextType>
    {
    public:
        PowerFunction(std::shared_ptr<Evaluator<ContextType>> childEvaluator,
                      float slope,
                      float intercept,
                      float exponent)
            : Curve<ContextType>{childEvaluator}, slope(slope), intercept(intercept), exponent(exponent)
        {
        }
 
        PowerFunction(std::shared_ptr<Evaluator<ContextType>> childEvaluator,
                      std::pair<float, float> firstPoint,
                      std::pair<float, float> secondPoint,
                      float exponent)
            : Curve<ContextType>{childEvaluator}, exponent{exponent}
        {
            if(firstPoint.first > secondPoint.first)
            {
                float x = firstPoint.first;
                float y = firstPoint.second;
                firstPoint.first = secondPoint.first;
                firstPoint.second = secondPoint.second;
                secondPoint.first = x;
                secondPoint.second = y;
            }
            slope = (std::pow(secondPoint.second, 1 / exponent) - std::pow(firstPoint.second, 1 / exponent)) / (
                        secondPoint.first - firstPoint.first);
            intercept = std::pow(firstPoint.second, 1 / exponent) - (slope * firstPoint.first);
        }
 
        virtual float Sample(float argument) const override final
        {
            float linearPart = slope * argument + intercept;
            if(linearPart < 0.0f)
            {
                int intExponent = static_cast<int>(exponent);
                if(exponent - intExponent > 0.0f)
                {
                    return 0.0f;
                }
            }
 
            return std::pow(linearPart, exponent);
        }
 
        float GetSlope() const { return slope; }
        float GetIntercept() const { return intercept; }
        float GetExponent() const { return exponent; }
 
        virtual data::EvaluatorType GetEvaluatorType() const override final { return data::EvaluatorType::CURVE_POWER; }
 
    private:
        float slope = 0.0f;
        float intercept = 0.0f;
        float exponent = 0.0f;
    };
}
}
 
#endif // GRAIL_POWER_FUNCTION_H