BivariateHermiteInterpolation.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef __UTILS_BIVARIATE_HERMITE_INTERPOLATION_H__
#define __UTILS_BIVARIATE_HERMITE_INTERPOLATION_H__
 
#include "HermiteInterpolation.h"
 
namespace Utils
{
 
class BivariateHermiteInterpolation
{
  public:
    // assumes the values in the proper order, if they are not, sort them out before calling this
    void SetSamples(const std::vector<std::vector<double>> &x, const std::vector<double> &y)
    {
        assert(x.size() == y.size());
        assert(!x.empty());
        assert(x[0].size() == 2);
 
        if (x.empty() || y.empty())
            return;
 
        interpolators.clear();
        xValues.clear();
 
        interpolators.emplace_back();
        interpolators.back().SetTrueInterpolation(trueInterpolation);
        xValues.push_back(x[0][0]);
 
        std::vector<double> xvals;
        std::vector<double> yvals;
 
        for (size_t i = 0; i < x.size(); ++i)
        {
            if (xValues.back() != x[i][0])
            {
                interpolators.back().SetSamples(xvals, yvals);
                xvals.clear();
                yvals.clear();
                interpolators.emplace_back();
                interpolators.back().SetTrueInterpolation(trueInterpolation);
                xValues.push_back(x[i][0]);
            }
 
            xvals.push_back(x[i][1]);
            yvals.push_back(y[i]);
        }
 
        if (!xvals.empty())
            interpolators.back().SetSamples(xvals, yvals);
    }
 
    double Predict(const std::vector<double> &x) const
    {
        assert(x.size() == 2);
 
        if (x.size() < 2)
            return 0;
 
        std::vector<double> vals;
        vals.reserve(interpolators.size());
 
        for (size_t i = 0; i < interpolators.size(); ++i)
        {
            const double pred = interpolators[i].Predict(x[1]);
            // std::cout << "Pred: " << pred << std::endl;
            vals.push_back(pred);
        }
 
        HermiteInterpolation secondInterpolator;
        secondInterpolator.SetTrueInterpolation(trueInterpolation);
        secondInterpolator.SetSamples(xValues, vals);
 
        const double val = secondInterpolator.Predict(x[0]);
 
        if (trueInterpolation)
            return val;
 
        const auto m = 1E-12;
        if (val < m)
            return m;
 
        return val;
    }
 
    void SetTrueInterpolation(bool reg)
    {
        trueInterpolation = reg;
 
        for (auto &interpolator : interpolators)
            interpolator.SetTrueInterpolation(reg);
    }
 
  private:
    std::vector<HermiteInterpolation> interpolators;
    std::vector<double> xValues;
 
    bool trueInterpolation = false;
};
 
} // namespace Utils
 
#endif // __UTILS_BIVARIATE_HERMITE_INTERPOLATION_H__