Line data    Source code

       1             : /*
       2             :  * XYdata.hpp
       3             :  *
       4             :  *  Created on: 07 Feb 2022
       5             :  *   Author(s): Jorn Reniers, Volkan Kumtepeli
       6             :  */
       7             : 
       8             : #pragma once
       9             : 
      10             : #include "FixedData.hpp"
      11             : #include "../utility/interpolation.hpp"
      12             : #include "../utility/io/read_CSVfiles.hpp"
      13             : 
      14             : #include <stdexcept>
      15             : #include <vector>
      16             : #include <array>
      17             : #include <functional>
      18             : #include <cmath>
      19             : #include <filesystem>
      20             : #include <type_traits>
      21             : #include <span>
      22             : 
      23             : namespace slide {
      24             : 
      25             : template <typename Tx>
      26         126 : bool check_is_fixed(Tx &xdat) //!< Checks if steps are fixed length. #TODO should not be here.
      27             : {
      28         126 :   const double dt = xdat[1] - xdat[0];
      29         126 :   const double tol = 0.01 * dt; //!< Tolerance.
      30             : 
      31         126 :   bool is_fixed = true;
      32             : 
      33         252 :   for (size_t i{ 1 }; i < (xdat.size() - 1); i++) {
      34         126 :     const double residual = std::abs(xdat[i + 1] - xdat[i] - dt);
      35         126 :     if (residual > tol) {
      36           0 :       is_fixed = false;
      37           0 :       break;
      38             :     }
      39             :   }
      40             : 
      41         126 :   return is_fixed;
      42             : }
      43             : 
      44             : template <typename Tx, typename Ty>
      45             : class XYdata
      46             : {
      47             :   bool is_fixed{ false };
      48             : 
      49             : public:
      50             :   Tx x;
      51             :   Ty y;
      52             : 
      53         126 :   XYdata() = default;
      54             :   explicit XYdata(size_t N) : x(N), y(N) {}
      55             :   XYdata(Tx &x_, Ty &y_) : x(x_), y(y_) { check_is_fixed(); }
      56             : 
      57             :   //!< XYdata(FixedData x, Ty y) : is_fixed(true), x(x), y(y) {} #TODO this should be on but error in GCC
      58             : 
      59             :   void reserve(int n) { x.reserve(n), y.reserve(n); }
      60             :   void clear() { x.clear(), y.clear(); }
      61             : 
      62             :   void resize(size_t n) { x.resize(n), y.resize(n); }
      63             : 
      64     2888602 :   double interp(double x_i, bool print = false, bool bound = true) // #TODO cannot put const here.
      65             :   {
      66     2888602 :     return linInt(print, bound, x, y, x.size(), x_i, is_fixed);
      67             :   }
      68             : 
      69             :   auto size() const { return y.size(); }
      70             : 
      71         126 :   void check_is_fixed()
      72             :   {
      73         126 :     is_fixed = slide::check_is_fixed(x);
      74         126 :   }
      75             : 
      76             :   template <typename Tpath>
      77             :   void setCurve(Tpath &&path)
      78             :   {
      79             :     loadCSV_2col(path, x, y);
      80             :     check_is_fixed();
      81             :   }
      82             : };
      83             : 
      84             : using XYdata_ff = XYdata<FixedData<double>, FixedData<double>>;
      85             : using XYdata_fv = XYdata<FixedData<double>, std::vector<double>>;
      86             : using XYdata_vv = XYdata<std::vector<double>, std::vector<double>>;
      87             : using XYdata_ss = XYdata<std::span<double>, std::span<double>>;
      88             : 
      89             : template <typename Tpath>
      90             : void loadCSV_2col(Tpath &&name, slide::XYdata_vv &data, int n = 0)
      91             : {
      92             :   //!< slide::XYdata_vv overload.
      93             :   loadCSV_2col(name, data.x, data.y, n);
      94             : }
      95             : 
      96             : } // namespace slide