1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
|
// Copyright 2018 Hans Dembinski
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/core/lightweight_test.hpp>
#include <boost/histogram/algorithm/reduce.hpp>
#include <boost/histogram/algorithm/sum.hpp>
#include <boost/histogram/axis/category.hpp>
#include <boost/histogram/axis/integer.hpp>
#include <boost/histogram/axis/ostream.hpp>
#include <boost/histogram/axis/regular.hpp>
#include <boost/histogram/axis/variable.hpp>
#include <boost/histogram/ostream.hpp>
#include <boost/histogram/unsafe_access.hpp>
#include <vector>
#include "throw_exception.hpp"
#include "utility_histogram.hpp"
using namespace boost::histogram;
using namespace boost::histogram::algorithm;
struct unreducible {
axis::index_type index(int) const { return 0; }
axis::index_type size() const { return 1; }
friend std::ostream& operator<<(std::ostream& os, const unreducible&) {
os << "unreducible";
return os;
}
};
template <typename Tag>
void run_tests() {
// limitations: shrink does not work with arguments not convertible to double
using R = axis::regular<double>;
using ID = axis::integer<double, axis::empty_type>;
using V = axis::variable<double, axis::empty_type>;
using CI = axis::category<int, axis::empty_type>;
// various failures
{
auto h = make(Tag(), R(4, 1, 5), R(3, -1, 2));
// not allowed: invalid axis index
BOOST_TEST_THROWS((void)reduce(h, slice(10, 2, 3)), std::invalid_argument);
// two slice requests for same axis not allowed
BOOST_TEST_THROWS((void)reduce(h, slice(1, 0, 2), slice(1, 1, 3)),
std::invalid_argument);
// two rebin requests for same axis not allowed
BOOST_TEST_THROWS((void)reduce(h, rebin(0, 2), rebin(0, 2)), std::invalid_argument);
// rebin and slice_and_rebin with merge > 1 requests for same axis cannot be fused
BOOST_TEST_THROWS((void)reduce(h, slice_and_rebin(0, 1, 3, 2), rebin(0, 2)),
std::invalid_argument);
BOOST_TEST_THROWS((void)reduce(h, shrink(1, 0, 2), crop(1, 0, 2)),
std::invalid_argument);
// not allowed: slice with begin >= end
BOOST_TEST_THROWS((void)reduce(h, slice(0, 1, 1)), std::invalid_argument);
BOOST_TEST_THROWS((void)reduce(h, slice(0, 2, 1)), std::invalid_argument);
// not allowed: shrink with lower == upper
BOOST_TEST_THROWS((void)reduce(h, shrink(0, 0, 0)), std::invalid_argument);
// not allowed: crop with lower == upper
BOOST_TEST_THROWS((void)reduce(h, crop(0, 0, 0)), std::invalid_argument);
// not allowed: shrink axis to zero size
BOOST_TEST_THROWS((void)reduce(h, shrink(0, 10, 11)), std::invalid_argument);
// not allowed: rebin with zero merge
BOOST_TEST_THROWS((void)reduce(h, rebin(0, 0)), std::invalid_argument);
// not allowed: reducing unreducible axis
BOOST_TEST_THROWS((void)reduce(make(Tag(), unreducible{}), slice(0, 1)),
std::invalid_argument);
}
// shrink and crop behavior when value on edge and not on edge is inclusive:
// - lower edge of shrink: pick bin which contains edge, lower <= x < upper
// - upper edge of shrink: pick bin which contains edge + 1, lower < x <= upper
{
auto h = make(Tag(), ID(0, 3));
const auto& ax = h.axis();
BOOST_TEST_EQ(ax.value(0), 0);
BOOST_TEST_EQ(ax.value(3), 3);
BOOST_TEST_EQ(ax.index(-1), -1);
BOOST_TEST_EQ(ax.index(3), 3);
BOOST_TEST_EQ(reduce(h, shrink(-1, 5)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, shrink(0, 3)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, shrink(1, 3)).axis(), ID(1, 3));
BOOST_TEST_EQ(reduce(h, shrink(1.001, 3)).axis(), ID(1, 3));
BOOST_TEST_EQ(reduce(h, shrink(1.999, 3)).axis(), ID(1, 3));
BOOST_TEST_EQ(reduce(h, shrink(2, 3)).axis(), ID(2, 3));
BOOST_TEST_EQ(reduce(h, shrink(0, 2.999)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, shrink(0, 2.001)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, shrink(0, 2)).axis(), ID(0, 2));
BOOST_TEST_EQ(reduce(h, shrink(0, 1.999)).axis(), ID(0, 2));
BOOST_TEST_EQ(reduce(h, crop(-1, 5)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, crop(0, 3)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, crop(1, 3)).axis(), ID(1, 3));
BOOST_TEST_EQ(reduce(h, crop(1.001, 3)).axis(), ID(1, 3));
BOOST_TEST_EQ(reduce(h, crop(1.999, 3)).axis(), ID(1, 3));
BOOST_TEST_EQ(reduce(h, crop(2, 3)).axis(), ID(2, 3));
BOOST_TEST_EQ(reduce(h, crop(0, 2.999)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, crop(0, 2.001)).axis(), ID(0, 3));
BOOST_TEST_EQ(reduce(h, crop(0, 2)).axis(), ID(0, 2));
BOOST_TEST_EQ(reduce(h, crop(0, 1.999)).axis(), ID(0, 2));
}
{
auto h = make_s(Tag(), std::vector<int>(), R(4, 1, 5, "1"), R(3, -1, 2, "2"));
/*
matrix layout:
x
y 1 0 1 0
1 1 0 0
0 2 1 3
*/
h.at(0, 0) = 1;
h.at(0, 1) = 1;
h.at(1, 1) = 1;
h.at(1, 2) = 2;
h.at(2, 0) = 1;
h.at(2, 2) = 1;
h.at(3, 2) = 3;
// should do nothing, index order does not matter
auto hr = reduce(h, shrink(1, -1, 2), rebin(0, 1));
BOOST_TEST_EQ(hr.rank(), 2);
BOOST_TEST_EQ(sum(hr), 10);
BOOST_TEST_EQ(hr.axis(0), R(4, 1, 5, "1"));
BOOST_TEST_EQ(hr.axis(1), R(3, -1, 2, "2"));
BOOST_TEST_EQ(hr, h);
// noop slice
hr = reduce(h, slice(1, 0, 4), slice(0, 0, 4));
BOOST_TEST_EQ(hr, h);
// shrinking along first axis
hr = reduce(h, shrink(0, 2, 4));
BOOST_TEST_EQ(hr.rank(), 2);
BOOST_TEST_EQ(sum(hr), 10);
BOOST_TEST_EQ(hr.axis(0), R(2, 2, 4, "1"));
BOOST_TEST_EQ(hr.axis(1), R(3, -1, 2, "2"));
BOOST_TEST_EQ(hr.at(-1, 0), 1); // underflow
BOOST_TEST_EQ(hr.at(0, 0), 0);
BOOST_TEST_EQ(hr.at(1, 0), 1);
BOOST_TEST_EQ(hr.at(2, 0), 0); // overflow
BOOST_TEST_EQ(hr.at(-1, 1), 1);
BOOST_TEST_EQ(hr.at(0, 1), 1);
BOOST_TEST_EQ(hr.at(1, 1), 0);
BOOST_TEST_EQ(hr.at(2, 1), 0);
BOOST_TEST_EQ(hr.at(-1, 2), 0);
BOOST_TEST_EQ(hr.at(0, 2), 2);
BOOST_TEST_EQ(hr.at(1, 2), 1);
BOOST_TEST_EQ(hr.at(2, 2), 3);
/*
matrix layout:
x
y 1 0 1 0
1 1 0 0
0 2 1 3
*/
hr = reduce(h, shrink_and_rebin(0, 2, 5, 2), rebin(1, 3));
BOOST_TEST_EQ(hr.rank(), 2);
BOOST_TEST_EQ(sum(hr), 10);
BOOST_TEST_EQ(hr.axis(0), R(1, 2, 4, "1"));
BOOST_TEST_EQ(hr.axis(1), R(1, -1, 2, "2"));
BOOST_TEST_EQ(hr.at(-1, 0), 2); // underflow
BOOST_TEST_EQ(hr.at(0, 0), 5);
BOOST_TEST_EQ(hr.at(1, 0), 3); // overflow
// test overload that accepts iterable and test option fusion
std::vector<reduce_command> opts{{shrink(0, 2, 5), rebin(0, 2), rebin(1, 3)}};
auto hr2 = reduce(h, opts);
BOOST_TEST_EQ(hr2, hr);
reduce_command opts2[3] = {rebin(1, 3), rebin(0, 2), shrink(0, 2, 5)};
auto hr3 = reduce(h, opts2);
BOOST_TEST_EQ(hr3, hr);
// test positional args
auto hr4 = reduce(h, shrink_and_rebin(2, 5, 2), rebin(3));
BOOST_TEST_EQ(hr4, hr);
}
// crop
{
auto h = make_s(Tag(), std::vector<int>(), R(4, 1, 5), R(3, 1, 4));
/*
matrix layout:
x
y 1 0 1 0
1 1 0 0
0 2 1 3
*/
h.at(0, 0) = 1;
h.at(0, 1) = 1;
h.at(1, 1) = 1;
h.at(1, 2) = 2;
h.at(2, 0) = 1;
h.at(2, 2) = 1;
h.at(3, 2) = 3;
/*
crop first and last column in x and y
matrix layout after:
x
y 3 1
*/
auto hr = reduce(h, crop(2, 4), crop_and_rebin(2, 4, 2));
BOOST_TEST_EQ(hr.rank(), 2);
BOOST_TEST_EQ(sum(hr), 4);
BOOST_TEST_EQ(hr.axis(0), R(2, 2, 4));
BOOST_TEST_EQ(hr.axis(1), R(1, 2, 4));
BOOST_TEST_EQ(hr.at(0, 0), 3);
BOOST_TEST_EQ(hr.at(1, 0), 1);
// slice with crop mode
auto hr2 = reduce(h, slice(1, 3, slice_mode::crop),
slice_and_rebin(1, 3, 2, slice_mode::crop));
BOOST_TEST_EQ(hr, hr2);
// explicit axis indices
auto hr3 = reduce(h, crop_and_rebin(1, 2, 4, 2), crop(0, 2, 4));
BOOST_TEST_EQ(hr, hr3);
auto hr4 = reduce(h, slice_and_rebin(1, 1, 3, 2, slice_mode::crop),
slice(0, 1, 3, slice_mode::crop));
BOOST_TEST_EQ(hr, hr4);
}
// mixed axis types
{
R r(5, 0.0, 5.0);
V v{{1., 2., 3.}};
CI c{{1, 2, 3}};
unreducible u;
auto h = make(Tag(), r, v, c, u);
auto hr = algorithm::reduce(h, shrink(0, 2, 4), slice(2, 1, 3));
BOOST_TEST_EQ(hr.axis(0), (R{2, 2, 4}));
BOOST_TEST_EQ(hr.axis(1), (V{{1., 2., 3.}}));
BOOST_TEST_EQ(hr.axis(2), (CI{{2, 3}}));
BOOST_TEST_EQ(hr.axis(3), u);
BOOST_TEST_THROWS((void)algorithm::reduce(h, rebin(2, 2)), std::invalid_argument);
}
// reduce on integer axis, rebin must fail
{
auto h = make(Tag(), axis::integer<>(1, 4));
BOOST_TEST_THROWS((void)reduce(h, rebin(2)), std::invalid_argument);
auto hr = reduce(h, shrink(2, 3));
BOOST_TEST_EQ(hr.axis().size(), 1);
BOOST_TEST_EQ(hr.axis().bin(0), 2);
BOOST_TEST_EQ(hr.axis().bin(1), 3);
}
// reduce on circular axis, shrink must fail, also rebin with remainder
{
auto h = make(Tag(), axis::circular<>(4, 1, 4));
BOOST_TEST_THROWS((void)reduce(h, shrink(0, 2)), std::invalid_argument);
BOOST_TEST_THROWS((void)reduce(h, rebin(3)), std::invalid_argument);
auto hr = reduce(h, rebin(2));
BOOST_TEST_EQ(hr.axis().size(), 2);
BOOST_TEST_EQ(hr.axis().bin(0).lower(), 1);
BOOST_TEST_EQ(hr.axis().bin(1).upper(), 4);
}
// reduce on variable axis
{
auto h = make(Tag(), V({0, 1, 2, 3, 4, 5, 6}));
auto hr = reduce(h, shrink_and_rebin(1, 5, 2));
BOOST_TEST_EQ(hr.axis().size(), 2);
BOOST_TEST_EQ(hr.axis().value(0), 1);
BOOST_TEST_EQ(hr.axis().value(1), 3);
BOOST_TEST_EQ(hr.axis().value(2), 5);
}
// reduce on axis with inverted range
{
auto h = make(Tag(), R(4, 2, -2));
const auto& ax = h.axis();
BOOST_TEST_EQ(ax.index(-0.999), 2);
BOOST_TEST_EQ(ax.index(-1.0), 3);
BOOST_TEST_EQ(ax.index(-1.5), 3);
BOOST_TEST_EQ(reduce(h, shrink(3, -3)).axis(), R(4, 2, -2));
BOOST_TEST_EQ(reduce(h, shrink(2, -2)).axis(), R(4, 2, -2));
BOOST_TEST_EQ(reduce(h, shrink(1.999, -2)).axis(), R(4, 2, -2));
BOOST_TEST_EQ(reduce(h, shrink(1.001, -2)).axis(), R(4, 2, -2));
BOOST_TEST_EQ(reduce(h, shrink(1, -2)).axis(), R(3, 1, -2));
BOOST_TEST_EQ(reduce(h, shrink(2, -1.999)).axis(), R(4, 2, -2));
BOOST_TEST_EQ(reduce(h, shrink(2, -1.001)).axis(), R(4, 2, -2));
BOOST_TEST_EQ(reduce(h, shrink(2, -1)).axis(), R(3, 2, -1));
}
// reduce on histogram with axis without flow bins, see GitHub issue #257
{
auto h = make(Tag(), axis::integer<int, use_default, axis::option::underflow_t>(0, 3),
axis::integer<int, use_default, axis::option::overflow_t>(0, 3));
std::fill(h.begin(), h.end(), 1);
/*
Original histogram:
x
-1 0 1 2
-------------
0| 1 1 1 1
x 1| 1 1 1 1
2| 1 1 1 1
3| 1 1 1 1
Shrunk histogram:
-1 0
-------
0| 2 1
1| 4 2
*/
auto hr = reduce(h, slice(0, 1, 2), slice(1, 1, 2));
BOOST_TEST_EQ(hr.size(), 2 * 2);
BOOST_TEST_EQ(hr.axis(0).size(), 1);
BOOST_TEST_EQ(hr.axis(1).size(), 1);
BOOST_TEST_EQ(hr.axis(0).bin(0), 1);
BOOST_TEST_EQ(hr.axis(1).bin(0), 1);
BOOST_TEST_EQ(hr.at(-1, 0), 2);
BOOST_TEST_EQ(hr.at(0, 0), 1);
BOOST_TEST_EQ(hr.at(-1, 1), 4);
BOOST_TEST_EQ(hr.at(0, 1), 2);
}
// reduce on category axis: removed bins are added to overflow bin
{
auto h = make(Tag(), CI{{1, 2, 3}});
std::fill(h.begin(), h.end(), 1);
// original: [1: 1, 2: 1, 3: 1, overflow: 1]
auto hr = reduce(h, slice(1, 2));
// reduced: [2: 1, overflow: 3]
BOOST_TEST_EQ(hr[0], 1);
BOOST_TEST_EQ(hr[1], 3);
}
}
int main() {
run_tests<static_tag>();
run_tests<dynamic_tag>();
return boost::report_errors();
}
|
