##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Shows min/max x-axis data in Variable widget (2)...
Alexandre Leroux -
r600:c613c4935e08
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,295 +1,306
1 1 #ifndef SCIQLOP_DATASERIES_H
2 2 #define SCIQLOP_DATASERIES_H
3 3
4 4 #include "CoreGlobal.h"
5 5
6 6 #include <Common/SortUtils.h>
7 7
8 8 #include <Data/ArrayData.h>
9 9 #include <Data/IDataSeries.h>
10 10
11 11 #include <QLoggingCategory>
12 12 #include <QReadLocker>
13 13 #include <QReadWriteLock>
14 14 #include <memory>
15 15
16 16 // We don't use the Qt macro since the log is used in the header file, which causes multiple log
17 17 // definitions with inheritance. Inline method is used instead
18 18 inline const QLoggingCategory &LOG_DataSeries()
19 19 {
20 20 static const QLoggingCategory category{"DataSeries"};
21 21 return category;
22 22 }
23 23
24 24 template <int Dim>
25 25 class DataSeries;
26 26
27 27 namespace dataseries_detail {
28 28
29 29 template <int Dim>
30 30 class IteratorValue : public DataSeriesIteratorValue::Impl {
31 31 public:
32 32 explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin)
33 33 : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
34 34 m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
35 35 : dataSeries.valuesData()->cend())
36 36 {
37 37 }
38 38 IteratorValue(const IteratorValue &other) = default;
39 39
40 40 std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
41 41 {
42 42 return std::make_unique<IteratorValue<Dim> >(*this);
43 43 }
44 44
45 45 bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
46 46 const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
47 47 return std::tie(m_XIt, m_ValuesIt) == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt);
48 48 }
49 49 catch (const std::bad_cast &) {
50 50 return false;
51 51 }
52 52
53 53 void next() override
54 54 {
55 55 ++m_XIt;
56 56 ++m_ValuesIt;
57 57 }
58 58
59 59 void prev() override
60 60 {
61 61 --m_XIt;
62 62 --m_ValuesIt;
63 63 }
64 64
65 65 double x() const override { return m_XIt->at(0); }
66 66 double value() const override { return m_ValuesIt->at(0); }
67 67 double value(int componentIndex) const override { return m_ValuesIt->at(componentIndex); }
68 68
69 69 private:
70 70 ArrayData<1>::Iterator m_XIt;
71 71 typename ArrayData<Dim>::Iterator m_ValuesIt;
72 72 };
73 73 } // namespace dataseries_detail
74 74
75 75 /**
76 76 * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
77 77 *
78 78 * It proposes to set a dimension for the values ​​data.
79 79 *
80 80 * A DataSeries is always sorted on its x-axis data.
81 81 *
82 82 * @tparam Dim The dimension of the values data
83 83 *
84 84 */
85 85 template <int Dim>
86 86 class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
87 87 public:
88 88 /// @sa IDataSeries::xAxisData()
89 89 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
90 90 const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
91 91
92 92 /// @sa IDataSeries::xAxisUnit()
93 93 Unit xAxisUnit() const override { return m_XAxisUnit; }
94 94
95 95 /// @return the values dataset
96 96 std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
97 97 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
98 98
99 99 /// @sa IDataSeries::valuesUnit()
100 100 Unit valuesUnit() const override { return m_ValuesUnit; }
101 101
102 102
103 103 SqpRange range() const override
104 104 {
105 105 if (!m_XAxisData->cdata().isEmpty()) {
106 106 return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
107 107 }
108 108
109 109 return SqpRange{};
110 110 }
111 111
112 112 void clear()
113 113 {
114 114 m_XAxisData->clear();
115 115 m_ValuesData->clear();
116 116 }
117 117
118 118 /// Merges into the data series an other data series
119 119 /// @remarks the data series to merge with is cleared after the operation
120 120 void merge(IDataSeries *dataSeries) override
121 121 {
122 122 dataSeries->lockWrite();
123 123 lockWrite();
124 124
125 125 if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
126 126 const auto &otherXAxisData = other->xAxisData()->cdata();
127 127 const auto &xAxisData = m_XAxisData->cdata();
128 128
129 129 // As data series are sorted, we can improve performances of merge, by call the sort
130 130 // method only if the two data series overlap.
131 131 if (!otherXAxisData.empty()) {
132 132 auto firstValue = otherXAxisData.front();
133 133 auto lastValue = otherXAxisData.back();
134 134
135 135 auto xAxisDataBegin = xAxisData.cbegin();
136 136 auto xAxisDataEnd = xAxisData.cend();
137 137
138 138 bool prepend;
139 139 bool sortNeeded;
140 140
141 141 if (std::lower_bound(xAxisDataBegin, xAxisDataEnd, firstValue) == xAxisDataEnd) {
142 142 // Other data series if after data series
143 143 prepend = false;
144 144 sortNeeded = false;
145 145 }
146 146 else if (std::upper_bound(xAxisDataBegin, xAxisDataEnd, lastValue)
147 147 == xAxisDataBegin) {
148 148 // Other data series if before data series
149 149 prepend = true;
150 150 sortNeeded = false;
151 151 }
152 152 else {
153 153 // The two data series overlap
154 154 prepend = false;
155 155 sortNeeded = true;
156 156 }
157 157
158 158 // Makes the merge
159 159 m_XAxisData->add(*other->xAxisData(), prepend);
160 160 m_ValuesData->add(*other->valuesData(), prepend);
161 161
162 162 if (sortNeeded) {
163 163 sort();
164 164 }
165 165 }
166 166
167 167 // Clears the other data series
168 168 other->clear();
169 169 }
170 170 else {
171 171 qCWarning(LOG_DataSeries())
172 172 << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
173 173 }
174 174 unlock();
175 175 dataSeries->unlock();
176 176 }
177 177
178 178 // ///////// //
179 179 // Iterators //
180 180 // ///////// //
181 181
182 182 DataSeriesIterator cbegin() const override
183 183 {
184 184 return DataSeriesIterator{DataSeriesIteratorValue{
185 185 std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, true)}};
186 186 }
187 187
188 188 DataSeriesIterator cend() const override
189 189 {
190 190 return DataSeriesIterator{DataSeriesIteratorValue{
191 191 std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, false)}};
192 192 }
193 193
194 194 /// @sa IDataSeries::minData()
195 195 DataSeriesIterator minData(double minXAxisData) const override
196 196 {
197 197 return std::lower_bound(
198 198 cbegin(), cend(), minXAxisData,
199 199 [](const auto &itValue, const auto &value) { return itValue.x() < value; });
200 200 }
201 201
202 /// @sa IDataSeries::maxData()
203 DataSeriesIterator maxData(double maxXAxisData) const override
204 {
205 // Gets the first element that greater than max value
206 auto it = std::upper_bound(
207 cbegin(), cend(), maxXAxisData,
208 [](const auto &value, const auto &itValue) { return value < itValue.x(); });
209
210 return it == cbegin() ? cend() : --it;
211 }
212
202 213 std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min, double max) const override
203 214 {
204 215 if (min > max) {
205 216 std::swap(min, max);
206 217 }
207 218
208 219 auto begin = cbegin();
209 220 auto end = cend();
210 221
211 222 auto lowerIt
212 223 = std::lower_bound(begin, end, min, [](const auto &itValue, const auto &value) {
213 224 return itValue.x() < value;
214 225 });
215 226 auto upperIt
216 227 = std::upper_bound(begin, end, max, [](const auto &value, const auto &itValue) {
217 228 return value < itValue.x();
218 229 });
219 230
220 231 return std::make_pair(lowerIt, upperIt);
221 232 }
222 233
223 234 // /////// //
224 235 // Mutexes //
225 236 // /////// //
226 237
227 238 virtual void lockRead() { m_Lock.lockForRead(); }
228 239 virtual void lockWrite() { m_Lock.lockForWrite(); }
229 240 virtual void unlock() { m_Lock.unlock(); }
230 241
231 242 protected:
232 243 /// Protected ctor (DataSeries is abstract). The vectors must have the same size, otherwise a
233 244 /// DataSeries with no values will be created.
234 245 /// @remarks data series is automatically sorted on its x-axis data
235 246 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
236 247 std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
237 248 : m_XAxisData{xAxisData},
238 249 m_XAxisUnit{xAxisUnit},
239 250 m_ValuesData{valuesData},
240 251 m_ValuesUnit{valuesUnit}
241 252 {
242 253 if (m_XAxisData->size() != m_ValuesData->size()) {
243 254 clear();
244 255 }
245 256
246 257 // Sorts data if it's not the case
247 258 const auto &xAxisCData = m_XAxisData->cdata();
248 259 if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
249 260 sort();
250 261 }
251 262 }
252 263
253 264 /// Copy ctor
254 265 explicit DataSeries(const DataSeries<Dim> &other)
255 266 : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
256 267 m_XAxisUnit{other.m_XAxisUnit},
257 268 m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
258 269 m_ValuesUnit{other.m_ValuesUnit}
259 270 {
260 271 // Since a series is ordered from its construction and is always ordered, it is not
261 272 // necessary to call the sort method here ('other' is sorted)
262 273 }
263 274
264 275 /// Assignment operator
265 276 template <int D>
266 277 DataSeries &operator=(DataSeries<D> other)
267 278 {
268 279 std::swap(m_XAxisData, other.m_XAxisData);
269 280 std::swap(m_XAxisUnit, other.m_XAxisUnit);
270 281 std::swap(m_ValuesData, other.m_ValuesData);
271 282 std::swap(m_ValuesUnit, other.m_ValuesUnit);
272 283
273 284 return *this;
274 285 }
275 286
276 287 private:
277 288 /**
278 289 * Sorts data series on its x-axis data
279 290 */
280 291 void sort() noexcept
281 292 {
282 293 auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
283 294 m_XAxisData = m_XAxisData->sort(permutation);
284 295 m_ValuesData = m_ValuesData->sort(permutation);
285 296 }
286 297
287 298 std::shared_ptr<ArrayData<1> > m_XAxisData;
288 299 Unit m_XAxisUnit;
289 300 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
290 301 Unit m_ValuesUnit;
291 302
292 303 QReadWriteLock m_Lock;
293 304 };
294 305
295 306 #endif // SCIQLOP_DATASERIES_H
Show file before | Show file after | Hide comments
@@ -1,92 +1,96
1 1 #ifndef SCIQLOP_IDATASERIES_H
2 2 #define SCIQLOP_IDATASERIES_H
3 3
4 4 #include <Common/MetaTypes.h>
5 5 #include <Data/DataSeriesIterator.h>
6 6 #include <Data/SqpRange.h>
7 7
8 8 #include <memory>
9 9
10 10 #include <QString>
11 11
12 12 template <int Dim>
13 13 class ArrayData;
14 14
15 15 struct Unit {
16 16 explicit Unit(const QString &name = {}, bool timeUnit = false)
17 17 : m_Name{name}, m_TimeUnit{timeUnit}
18 18 {
19 19 }
20 20
21 21 inline bool operator==(const Unit &other) const
22 22 {
23 23 return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
24 24 }
25 25 inline bool operator!=(const Unit &other) const { return !(*this == other); }
26 26
27 27 QString m_Name; ///< Unit name
28 28 bool m_TimeUnit; ///< The unit is a unit of time (UTC)
29 29 };
30 30
31 31 /**
32 32 * @brief The IDataSeries aims to declare a data series.
33 33 *
34 34 * A data series is an entity that contains at least :
35 35 * - one dataset representing the x-axis
36 36 * - one dataset representing the values
37 37 *
38 38 * Each dataset is represented by an ArrayData, and is associated with a unit.
39 39 *
40 40 * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
41 41 * IDataSeries. The x-axis dataset is always unidimensional.
42 42 *
43 43 * @sa ArrayData
44 44 */
45 45 class IDataSeries {
46 46 public:
47 47 virtual ~IDataSeries() noexcept = default;
48 48
49 49 /// Returns the x-axis dataset
50 50 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
51 51
52 52 /// Returns the x-axis dataset (as const)
53 53 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
54 54
55 55 virtual Unit xAxisUnit() const = 0;
56 56
57 57 virtual Unit valuesUnit() const = 0;
58 58
59 59 virtual void merge(IDataSeries *dataSeries) = 0;
60 60 /// @todo Review the name and signature of this method
61 61 virtual std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) = 0;
62 62
63 63 virtual std::unique_ptr<IDataSeries> clone() const = 0;
64 64 virtual SqpRange range() const = 0;
65 65
66 66 // ///////// //
67 67 // Iterators //
68 68 // ///////// //
69 69
70 70 virtual DataSeriesIterator cbegin() const = 0;
71 71 virtual DataSeriesIterator cend() const = 0;
72 72
73 73 /// @return the iterator to the first entry of the data series whose x-axis data is greater than
74 74 /// or equal to the value passed in parameter, or the end iterator if there is no matching value
75 75 virtual DataSeriesIterator minData(double minXAxisData) const = 0;
76 76
77 /// @return the iterator to the last entry of the data series whose x-axis data is less than or
78 /// equal to the value passed in parameter, or the end iterator if there is no matching value
79 virtual DataSeriesIterator maxData(double maxXAxisData) const = 0;
80
77 81 virtual std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min,
78 82 double max) const = 0;
79 83
80 84 // /////// //
81 85 // Mutexes //
82 86 // /////// //
83 87
84 88 virtual void lockRead() = 0;
85 89 virtual void lockWrite() = 0;
86 90 virtual void unlock() = 0;
87 91 };
88 92
89 93 // Required for using shared_ptr in signals/slots
90 94 SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
91 95
92 96 #endif // SCIQLOP_IDATASERIES_H
Show file before | Show file after | Hide comments
@@ -1,291 +1,354
1 1 #include "Data/DataSeries.h"
2 2 #include "Data/ScalarSeries.h"
3 3
4 4 #include <QObject>
5 5 #include <QtTest>
6 6
7 7 Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
8 8
9 9 class TestDataSeries : public QObject {
10 10 Q_OBJECT
11 11 private slots:
12 12 /// Input test data
13 13 /// @sa testCtor()
14 14 void testCtor_data();
15 15
16 16 /// Tests construction of a data series
17 17 void testCtor();
18 18
19 19 /// Input test data
20 20 /// @sa testMerge()
21 21 void testMerge_data();
22 22
23 23 /// Tests merge of two data series
24 24 void testMerge();
25 25
26 26 /// Input test data
27 27 /// @sa testMinData()
28 28 void testMinData_data();
29 29
30 30 /// Tests get min data of a data series
31 31 void testMinData();
32 32
33 /// Input test data
34 /// @sa testMaxData()
35 void testMaxData_data();
36
37 /// Tests get max data of a data series
38 void testMaxData();
39
40 /// Input test data
33 41 /// @sa testSubdata()
34 42 void testSubdata_data();
35 43
36 44 /// Tests get subdata of two data series
37 45 void testSubdata();
38 46 };
39 47
40 48 void TestDataSeries::testCtor_data()
41 49 {
42 50 // ////////////// //
43 51 // Test structure //
44 52 // ////////////// //
45 53
46 54 // x-axis data
47 55 QTest::addColumn<QVector<double> >("xAxisData");
48 56 // values data
49 57 QTest::addColumn<QVector<double> >("valuesData");
50 58
51 59 // expected x-axis data
52 60 QTest::addColumn<QVector<double> >("expectedXAxisData");
53 61 // expected values data
54 62 QTest::addColumn<QVector<double> >("expectedValuesData");
55 63
56 64 // ////////// //
57 65 // Test cases //
58 66 // ////////// //
59 67
60 68 QTest::newRow("invalidData (different sizes of vectors)")
61 69 << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 200., 300.}
62 70 << QVector<double>{} << QVector<double>{};
63 71
64 72 QTest::newRow("sortedData") << QVector<double>{1., 2., 3., 4., 5.}
65 73 << QVector<double>{100., 200., 300., 400., 500.}
66 74 << QVector<double>{1., 2., 3., 4., 5.}
67 75 << QVector<double>{100., 200., 300., 400., 500.};
68 76
69 77 QTest::newRow("unsortedData") << QVector<double>{5., 4., 3., 2., 1.}
70 78 << QVector<double>{100., 200., 300., 400., 500.}
71 79 << QVector<double>{1., 2., 3., 4., 5.}
72 80 << QVector<double>{500., 400., 300., 200., 100.};
73 81
74 82 QTest::newRow("unsortedData2")
75 83 << QVector<double>{1., 4., 3., 5., 2.} << QVector<double>{100., 200., 300., 400., 500.}
76 84 << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 500., 300., 200., 400.};
77 85 }
78 86
79 87 void TestDataSeries::testCtor()
80 88 {
81 89 // Creates series
82 90 QFETCH(QVector<double>, xAxisData);
83 91 QFETCH(QVector<double>, valuesData);
84 92
85 93 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
86 94 Unit{}, Unit{});
87 95
88 96 // Validates results : we check that the data series is sorted on its x-axis data
89 97 QFETCH(QVector<double>, expectedXAxisData);
90 98 QFETCH(QVector<double>, expectedValuesData);
91 99
92 100 auto seriesXAxisData = series->xAxisData()->data();
93 101 auto seriesValuesData = series->valuesData()->data();
94 102
95 103 QVERIFY(
96 104 std::equal(expectedXAxisData.cbegin(), expectedXAxisData.cend(), seriesXAxisData.cbegin()));
97 105 QVERIFY(std::equal(expectedValuesData.cbegin(), expectedValuesData.cend(),
98 106 seriesValuesData.cbegin()));
99 107 }
100 108
101 109 namespace {
102 110
103 111 std::shared_ptr<ScalarSeries> createSeries(QVector<double> xAxisData, QVector<double> valuesData)
104 112 {
105 113 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
106 114 Unit{});
107 115 }
108 116
109 117 } // namespace
110 118
111 119 void TestDataSeries::testMerge_data()
112 120 {
113 121 // ////////////// //
114 122 // Test structure //
115 123 // ////////////// //
116 124
117 125 // Data series to merge
118 126 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
119 127 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
120 128
121 129 // Expected values in the first data series after merge
122 130 QTest::addColumn<QVector<double> >("expectedXAxisData");
123 131 QTest::addColumn<QVector<double> >("expectedValuesData");
124 132
125 133 // ////////// //
126 134 // Test cases //
127 135 // ////////// //
128 136
129 137 QTest::newRow("sortedMerge")
130 138 << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
131 139 << createSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
132 140 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
133 141 << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
134 142
135 143 QTest::newRow("unsortedMerge")
136 144 << createSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
137 145 << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
138 146 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
139 147 << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
140 148
141 149 QTest::newRow("unsortedMerge2")
142 150 << createSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
143 151 << createSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
144 152 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
145 153 << QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
146 154
147 155 QTest::newRow("unsortedMerge3")
148 156 << createSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
149 157 << createSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
150 158 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
151 159 << QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
152 160 }
153 161
154 162 void TestDataSeries::testMerge()
155 163 {
156 164 // Merges series
157 165 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
158 166 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
159 167
160 168 dataSeries->merge(dataSeries2.get());
161 169
162 170 // Validates results : we check that the merge is valid and the data series is sorted on its
163 171 // x-axis data
164 172 QFETCH(QVector<double>, expectedXAxisData);
165 173 QFETCH(QVector<double>, expectedValuesData);
166 174
167 175 auto seriesXAxisData = dataSeries->xAxisData()->data();
168 176 auto seriesValuesData = dataSeries->valuesData()->data();
169 177
170 178 QVERIFY(
171 179 std::equal(expectedXAxisData.cbegin(), expectedXAxisData.cend(), seriesXAxisData.cbegin()));
172 180 QVERIFY(std::equal(expectedValuesData.cbegin(), expectedValuesData.cend(),
173 181 seriesValuesData.cbegin()));
174 182 }
175 183
176 184 void TestDataSeries::testMinData_data()
177 185 {
178 186 // ////////////// //
179 187 // Test structure //
180 188 // ////////////// //
181 189
182 190 // Data series to get min data
183 191 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
184 192
185 193 // Min data
186 194 QTest::addColumn<double>("min");
187 195
188 196 // Expected results
189 197 QTest::addColumn<bool>(
190 198 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
191 199 QTest::addColumn<double>(
192 200 "expectedMin"); // Expected value when method doesn't return end iterator
193 201
194 202 // ////////// //
195 203 // Test cases //
196 204 // ////////// //
197 205
198 206 QTest::newRow("minData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
199 207 << 0. << true << 1.;
200 208 QTest::newRow("minData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
201 209 << 1. << true << 1.;
202 210 QTest::newRow("minData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
203 211 << 1.1 << true << 2.;
204 212 QTest::newRow("minData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
205 213 << 5. << true << 5.;
206 214 QTest::newRow("minData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
207 215 << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
208 216 QTest::newRow("minData6") << createSeries({}, {}) << 1.1 << false
209 217 << std::numeric_limits<double>::quiet_NaN();
210 218 }
211 219
212 220 void TestDataSeries::testMinData()
213 221 {
214 222 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
215 223 QFETCH(double, min);
216 224
217 225 QFETCH(bool, expectedOK);
218 226 QFETCH(double, expectedMin);
219 227
220 228 auto it = dataSeries->minData(min);
221 229
222 230 QCOMPARE(expectedOK, it != dataSeries->cend());
223 231
224 232 // If the method doesn't return a end iterator, checks with expected value
225 233 if (expectedOK) {
226 234 QCOMPARE(expectedMin, it->x());
227 235 }
228 236 }
237
238 void TestDataSeries::testMaxData_data()
239 {
240 // ////////////// //
241 // Test structure //
242 // ////////////// //
243
244 // Data series to get max data
245 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
246
247 // Max data
248 QTest::addColumn<double>("max");
249
250 // Expected results
251 QTest::addColumn<bool>(
252 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
253 QTest::addColumn<double>(
254 "expectedMax"); // Expected value when method doesn't return end iterator
255
256 // ////////// //
257 // Test cases //
258 // ////////// //
259
260 QTest::newRow("maxData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
261 << 6. << true << 5.;
262 QTest::newRow("maxData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
263 << 5. << true << 5.;
264 QTest::newRow("maxData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
265 << 4.9 << true << 4.;
266 QTest::newRow("maxData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
267 << 1.1 << true << 1.;
268 QTest::newRow("maxData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
269 << 1. << true << 1.;
270 QTest::newRow("maxData6") << createSeries({}, {}) << 1.1 << false
271 << std::numeric_limits<double>::quiet_NaN();
272 }
273
274 void TestDataSeries::testMaxData()
275 {
276 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
277 QFETCH(double, max);
278
279 QFETCH(bool, expectedOK);
280 QFETCH(double, expectedMax);
281
282 auto it = dataSeries->maxData(max);
283
284 QCOMPARE(expectedOK, it != dataSeries->cend());
285
286 // If the method doesn't return a end iterator, checks with expected value
287 if (expectedOK) {
288 QCOMPARE(expectedMax, it->x());
289 }
290 }
291
229 292 void TestDataSeries::testSubdata_data()
230 293 {
231 294 // ////////////// //
232 295 // Test structure //
233 296 // ////////////// //
234 297
235 298 // Data series to get subdata
236 299 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
237 300
238 301 // Min/max values
239 302 QTest::addColumn<double>("min");
240 303 QTest::addColumn<double>("max");
241 304
242 305 // Expected values after subdata
243 306 QTest::addColumn<QVector<double> >("expectedXAxisData");
244 307 QTest::addColumn<QVector<double> >("expectedValuesData");
245 308
246 309 // ////////// //
247 310 // Test cases //
248 311 // ////////// //
249 312
250 313 QTest::newRow("subData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
251 314 << -1. << 3.2 << QVector<double>{1., 2., 3.}
252 315 << QVector<double>{100., 200., 300.};
253 316 QTest::newRow("subData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
254 317 << 1. << 4. << QVector<double>{1., 2., 3., 4.}
255 318 << QVector<double>{100., 200., 300., 400.};
256 319 QTest::newRow("subData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
257 320 << 1. << 3.9 << QVector<double>{1., 2., 3.}
258 321 << QVector<double>{100., 200., 300.};
259 322 QTest::newRow("subData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
260 323 << 0. << 0.9 << QVector<double>{} << QVector<double>{};
261 324 QTest::newRow("subData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
262 325 << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
263 326 QTest::newRow("subData6") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
264 327 << 2.1 << 6. << QVector<double>{3., 4., 5.}
265 328 << QVector<double>{300., 400., 500.};
266 329 QTest::newRow("subData7") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
267 330 << 6. << 9. << QVector<double>{} << QVector<double>{};
268 331 QTest::newRow("subData8") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
269 332 << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
270 333 }
271 334
272 335 void TestDataSeries::testSubdata()
273 336 {
274 337 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
275 338 QFETCH(double, min);
276 339 QFETCH(double, max);
277 340
278 341 QFETCH(QVector<double>, expectedXAxisData);
279 342 QFETCH(QVector<double>, expectedValuesData);
280 343
281 344 auto bounds = dataSeries->subData(min, max);
282 345 QVERIFY(std::equal(bounds.first, bounds.second, expectedXAxisData.cbegin(),
283 346 expectedXAxisData.cend(),
284 347 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
285 348 QVERIFY(std::equal(
286 349 bounds.first, bounds.second, expectedValuesData.cbegin(), expectedValuesData.cend(),
287 350 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
288 351 }
289 352
290 353 QTEST_MAIN(TestDataSeries)
291 354 #include "TestDataSeries.moc"
General Comments 0
You need to be logged in to leave comments. Login now