Line data Source code
1 : /*
2 : * FixedData.hpp
3 : *
4 : * Created on: 07 Feb 2022
5 : * Author(s): Jorn Reniers, Volkan Kumtepeli
6 : */
7 :
8 : #pragma once
9 :
10 : #include <stdexcept>
11 : #include <vector>
12 : #include <array>
13 : #include <functional>
14 : #include <cmath>
15 : #include <filesystem>
16 :
17 : namespace slide {
18 : template <typename T, bool extrapolation = true>
19 : class FixedData;
20 :
21 : template <typename T, bool extrapolation = true>
22 : class FixedDataIter
23 : { //!< For more information, see: https://internalpointers.com/post/writing-custom-iterators-modern-cpp
24 : public:
25 : using iterator_category = std::input_iterator_tag;
26 : using difference_type = int;
27 : using value_type = T;
28 : using pointer = value_type *;
29 : using reference = value_type &;
30 :
31 0 : FixedDataIter(FixedData<T, extrapolation> *const f_data_ptr_, int n_) : f_data_ptr{ f_data_ptr_ }, n{ n_ } {}
32 :
33 0 : FixedDataIter &operator++() //!< Prefix increment
34 : {
35 0 : n++;
36 0 : return *this;
37 : }
38 :
39 : FixedDataIter operator++(int) //!< Postfix increment
40 : {
41 : FixedDataIter temp = *this;
42 : ++(*this);
43 : return temp;
44 : }
45 :
46 : FixedDataIter &operator--() //!< Prefix decrement
47 : {
48 : n--;
49 : return *this;
50 : }
51 :
52 : FixedDataIter operator--(int) //!< Postfix decrement
53 : {
54 : FixedDataIter temp = *this;
55 : --(*this);
56 : return temp;
57 : }
58 :
59 : value_type operator[](int i)
60 : {
61 : return f_data_ptr->operator[](i);
62 : }
63 :
64 0 : const value_type operator*() const { return f_data_ptr->operator[](n); }
65 :
66 : friend bool operator==(const FixedDataIter &a, const FixedDataIter &b) { return a.n == b.n; }
67 0 : friend bool operator!=(const FixedDataIter &a, const FixedDataIter &b) { return a.n != b.n; }
68 :
69 0 : friend FixedDataIter operator+(const FixedDataIter &a, const int b)
70 : {
71 0 : return FixedDataIter{ a.f_data_ptr, a.n + b };
72 : }
73 :
74 0 : friend difference_type operator-(const FixedDataIter &a, const FixedDataIter &b)
75 : {
76 0 : return a.n - b.n;
77 : }
78 :
79 : private:
80 : FixedData<T, extrapolation> *f_data_ptr;
81 : int n;
82 : };
83 :
84 : template <typename T, bool extrapolation = true>
85 : int distance(const FixedDataIter<T, extrapolation> &a, const FixedDataIter<T, extrapolation> &b)
86 : {
87 : return a - b;
88 : }
89 :
90 : template <typename T, bool extrapolation>
91 : class FixedData
92 : {
93 : using size_type = int;
94 : T x_min{};
95 : T dx{};
96 : size_type n{};
97 31775120 : std::function<T(T, T, int)> F = [](T x_min_, T dx_, size_type i) { return x_min_ + i * dx_; }; // #TODO important problem here!
98 :
99 : public:
100 252 : FixedData() = default;
101 252 : FixedData(T x_min_, T dx_, int n_) : x_min(x_min_), dx(dx_), n(n_) {}
102 : FixedData(T x_min_, T dx_, int n_, std::function<T(T, T, int)> F_) : x_min(x_min_), dx(dx_), n(n_), F(F_) {}
103 :
104 31775120 : T operator[](int i) const
105 : {
106 :
107 : if constexpr (!extrapolation) //!< Extrapolation will be deprecated.
108 : {
109 : if (i >= n || i < 0) {
110 : std::cout << i << ' ' << n << '\n';
111 : throw std::out_of_range("fixed data is out of range");
112 : }
113 : }
114 :
115 31775120 : auto x = F(x_min, dx, i);
116 31775120 : return x;
117 : }
118 :
119 : T operator()(int i) const //!< Can extrapolate (go out of bounds).
120 : {
121 : return F(x_min, dx, i);
122 : }
123 :
124 0 : [[nodiscard]] constexpr FixedDataIter<T, extrapolation> begin() noexcept { return FixedDataIter(this, 0); }
125 : [[nodiscard]] constexpr FixedDataIter<T, extrapolation> end() noexcept { return FixedDataIter(this, n); }
126 :
127 : [[nodiscard]] constexpr const FixedDataIter<T, extrapolation> cbegin() const noexcept { return FixedDataIter(this, 0); }
128 : [[nodiscard]] constexpr const FixedDataIter<T, extrapolation> cend() const noexcept { return FixedDataIter(this, n); }
129 :
130 : T back() const { return operator[](n - 1); }
131 : T front() const { return operator[](0); }
132 : T dstep() const noexcept { return dx; }
133 :
134 : T prev(T x_current) noexcept
135 : {
136 : //!< Gets previous point compared to the current point x_current
137 : auto temp_data = *this;
138 : temp_data.x_min = x_current;
139 : return temp_data(-1);
140 : }
141 :
142 : T next(T x_current) noexcept
143 : {
144 : //!< Gets next point compared to the current point x_current
145 : auto temp_data = *this;
146 : temp_data.x_min = x_current;
147 : return temp_data(+1);
148 : }
149 :
150 : constexpr void reserve(int n_) noexcept {}
151 : constexpr void clear() noexcept
152 : {
153 : x_min = 0;
154 : dx = 0;
155 : n = 0;
156 : }
157 2888854 : constexpr auto size() const noexcept { return static_cast<size_t>(n); }
158 : };
159 : } // namespace slide
|
