PowerFunction.hh

#ifndef GRAIL_POWER_FUNCTION_H
#define GRAIL_POWER_FUNCTION_H
 
#include <cmath>
#include "Curve.hh"
 
namespace grail
{
    namespace curves
    {
        template <typename ContextType>
        class PowerFunction final : public Curve<ContextType>
        {
        public:
            PowerFunction(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator,
                          float slope,
                          float intercept,
                          float exponent)
                : Curve<ContextType>{childEvaluator}, slope(slope), intercept(intercept), exponent(exponent)
            {
            }
 
            PowerFunction(std::shared_ptr<utility::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 EvaluatorType GetEvaluatorType() const override final { return EvaluatorType::CURVE_POWER; }
 
        private:
            float slope = 0.0f;
            float intercept = 0.0f;
            float exponent = 0.0f;
        };
    }
}
 
#endif // GRAIL_POWER_FUNCTION_H