Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <gsl/gsl_spline.h>
       7             : #include <memory>
       8             : #include <vector>
       9             : 
      10             : /// \cond
      11             : namespace PUP {
      12             : class er;
      13             : }  // namespace PUP
      14             : /// \endcond
      15             : 
      16             : namespace intrp {
      17             : /*!
      18             :  * \ingroup NumericalAlgorithmsGroup
      19             :  * \brief A natural cubic spline interpolation class
      20             :  *
      21             :  * The class builds a cubic spline interpolant with natural boundary conditions
      22             :  * using the `x_values` and `y_values` passed into the constructor. For details
      23             :  * on the algorithm see the GSL documentation on `gsl_interp_cspline`.
      24             :  *
      25             :  * Here is an example how to use this class:
      26             :  *
      27             :  * \snippet Test_CubicSpline.cpp interpolate_example
      28             :  */
      29           1 : class CubicSpline {
      30             :  public:
      31           0 :   CubicSpline(std::vector<double> x_values, std::vector<double> y_values);
      32             : 
      33           0 :   CubicSpline() = default;
      34           0 :   CubicSpline(const CubicSpline& /*rhs*/);
      35           0 :   CubicSpline& operator=(const CubicSpline& /*rhs*/);
      36           0 :   CubicSpline(CubicSpline&& /*rhs*/) = default;
      37           0 :   CubicSpline& operator=(CubicSpline&& rhs) = default;
      38           0 :   ~CubicSpline() = default;
      39             : 
      40           0 :   bool operator==(const CubicSpline& rhs) const;
      41             : 
      42           0 :   double operator()(double x_to_interp_to) const;
      43             : 
      44           0 :   const std::vector<double>& x_values() const { return x_values_; }
      45             : 
      46           0 :   const std::vector<double>& y_values() const { return y_values_; }
      47             : 
      48             :   // NOLINTNEXTLINE(google-runtime-references)
      49           0 :   void pup(PUP::er& p);
      50             : 
      51             :  private:
      52           0 :   struct gsl_interp_accel_deleter {
      53           0 :     void operator()(gsl_interp_accel* acc) const;
      54             :   };
      55           0 :   struct gsl_spline_deleter {
      56           0 :     void operator()(gsl_spline* spline) const;
      57             :   };
      58             : 
      59           0 :   void initialize_interpolant();
      60             : 
      61           0 :   std::vector<double> x_values_;
      62           0 :   std::vector<double> y_values_;
      63           0 :   std::unique_ptr<gsl_interp_accel, gsl_interp_accel_deleter> acc_;
      64           0 :   std::unique_ptr<gsl_spline, gsl_spline_deleter> spline_;
      65             : };
      66             : }  // namespace intrp