All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Functions
TensorIndices_test.cc File Reference

Test for TensorIndices class. More...

#include "lardata/Utilities/TensorIndices.h"
#include "boost/test/unit_test.hpp"
#include <stdexcept>

Go to the source code of this file.

Macros

#define BOOST_TEST_MODULE   ( PointIsolationAlg_test )
 

Functions

void VectorTest ()
 Test for a rank 1 tensor (vector) More...
 
void MatrixTest ()
 Test for a rank 2 tensor (matrix) More...
 
void TensorRank3Test ()
 Test for a rank 3 tensor. More...
 
 BOOST_AUTO_TEST_CASE (VectorTestCase)
 
 BOOST_AUTO_TEST_CASE (MatrixTestCase)
 
 BOOST_AUTO_TEST_CASE (TensorRank3TestCase)
 

Detailed Description

Test for TensorIndices class.

Author
Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)
Date
June 28, 2016
See Also
TensorIndices.h

This test instantiates some TensorIndices and verifies the reaction to some hard-coded settings and queries.

The test is run with no arguments.

Tests are run:

See the documentation of the three functions for more information.

Definition in file TensorIndices_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( PointIsolationAlg_test )

Definition at line 27 of file TensorIndices_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE ( VectorTestCase  )

Definition at line 310 of file TensorIndices_test.cc.

310  {
311  VectorTest();
312 } // VectorTestCase
VectorTest
void VectorTest()
Definition: DumpUtils_test.cc:142
BOOST_AUTO_TEST_CASE ( MatrixTestCase  )

Definition at line 314 of file TensorIndices_test.cc.

314  {
315  MatrixTest();
316 } // MatrixTestCase
MatrixTest
void MatrixTest(Array const &mat)
Definition: FastMatrixMath_test.cc:114
BOOST_AUTO_TEST_CASE ( TensorRank3TestCase  )

Definition at line 318 of file TensorIndices_test.cc.

318  {
319  TensorRank3Test();
320 } // TensorRank3TestCase
TensorRank3Test
void TensorRank3Test()
Test for a rank 3 tensor.
Definition: TensorIndices_test.cc:213
void MatrixTest ( )

Test for a rank 2 tensor (matrix)

Definition at line 124 of file TensorIndices_test.cc.

124  {
125 
126  // indices for a matrix 4 x 3
127  util::TensorIndices<2> const indices{4, 3};
128 
129  //
130  // reflection
131  //
132  BOOST_TEST(indices.dim<0>() == 4U);
133  BOOST_TEST(indices.dim<1>() == 3U);
134 
135  BOOST_TEST(indices.size<0>() == 4U * 3U);
136  BOOST_TEST(indices.size<1>() == 3U);
137 
138  BOOST_TEST(indices.size() == 4U * 3U);
139 
140  BOOST_TEST(indices.minorTensor().rank() == 1U);
141  BOOST_TEST(indices.minorTensor().size() == 3U);
142 
143  //
144  // indexing
145  //
146  // BUG the double brace syntax is required to work around clang bug 21629
147  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
148  std::array<char, 2> ii {{ 1, 2 }}; // char is for test; it should be size_t
149 /* TODO
150  BOOST_TEST(indices[0] == 0U);
151  BOOST_TEST(indices[1] == 1U);
152  BOOST_TEST(indices[2] == 2U);
153  BOOST_TEST(indices[3] == 3U);
154  BOOST_TEST(indices[4] == 4U); // no bound check
155 */
156  BOOST_TEST(indices(0, 0) == 0U);
157  BOOST_TEST(indices(1, 2) == 5U);
158  BOOST_TEST(indices(ii.begin()) == 5U);
159  BOOST_CHECK_NO_THROW(indices(1, 3));
160  BOOST_CHECK_NO_THROW(indices(4, 2));
161  BOOST_CHECK_NO_THROW(indices(7, 6));
162 
163  BOOST_TEST(indices.at(0, 0) == 0U);
164  BOOST_TEST(indices.at(1, 2) == 5U);
165  BOOST_TEST(indices.at(ii.begin()) == 5U);
166  BOOST_CHECK_THROW(indices.at(1, 3), std::out_of_range);
167  BOOST_CHECK_THROW(indices.at(4, 2), std::out_of_range);
168  BOOST_CHECK_THROW(indices.at(7, 6), std::out_of_range);
169 
170  BOOST_TEST(indices.has(0, 0));
171  BOOST_TEST(indices.has(ii.begin()));
172  BOOST_TEST(indices.has(2, 2));
173  BOOST_TEST(!indices.has(1, 3));
174  BOOST_TEST(!indices.has(4, 2));
175  BOOST_TEST(!indices.has(7, 6));
176 
177  BOOST_TEST( indices.hasIndex<0>(0));
178  BOOST_TEST( indices.hasIndex<0>(3));
179  BOOST_TEST(!indices.hasIndex<0>(4));
180  BOOST_TEST( indices.hasIndex<1>(0));
181  BOOST_TEST( indices.hasIndex<1>(2));
182  BOOST_TEST(!indices.hasIndex<1>(3));
183 
184  BOOST_TEST(indices.hasLinIndex(0U));
185  BOOST_TEST(indices.hasLinIndex(indices.size() - 1));
186  BOOST_TEST(!indices.hasLinIndex(indices.size()));
187 
188  //
189  // comparisons
190  //
191  // check that the function and other constructors also works
192  // BUG the double brace syntax is required to work around clang bug 21629
193  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
194  std::array<int, 2> ia {{ 4, 3 }};
195  util::TensorIndices<2> indicesAgain(ia.begin());
196  util::TensorIndices<2> indicesOther = util::makeTensorIndices(4, 4);
197  util::TensorIndices<3> indicesRank = util::makeTensorIndices(5, 4, 3);
198 
199  // check the comparison operators
200  BOOST_TEST((indicesAgain == indices));
201  BOOST_TEST(!(indicesAgain != indices));
202  BOOST_TEST((indicesOther != indices));
203  BOOST_TEST(!(indicesOther == indices));
204  BOOST_TEST((indicesRank != indices));
205  BOOST_TEST(!(indicesRank == indices));
206 
207 } // MatrixTest()
util::TensorIndices
Converts a tensor element specification into a linear index.
Definition: TensorIndices.h:46
geo::vect::indices
constexpr std::array< std::size_t, geo::vect::dimension< Vector >)> indices()
Returns a sequence of indices valid for a vector of the specified type.
Definition: geo_vectors_utils.h:2022
util::makeTensorIndices
auto makeTensorIndices(DIMS...dims)
Instantiates a TensorIndices class with the specified dimensions.
Definition: TensorIndices.h:543
void TensorRank3Test ( )

Test for a rank 3 tensor.

Definition at line 213 of file TensorIndices_test.cc.

213  {
214 
215  // indices for a matrix 2 x 3 x 4
216  util::TensorIndices<3> const indices{ 2, 3, 4 };
217 
218  //
219  // reflection
220  //
221  BOOST_TEST(indices.dim<0>() == 2U);
222  BOOST_TEST(indices.dim<1>() == 3U);
223  BOOST_TEST(indices.dim<2>() == 4U);
224 
225  BOOST_TEST(indices.size<0>() == 2U * 3U * 4U);
226  BOOST_TEST(indices.size<1>() == 3U * 4U);
227  BOOST_TEST(indices.size<2>() == 4U);
228 
229  BOOST_TEST(indices.size() == 2U * 3U * 4U);
230 
231  BOOST_TEST(indices.minorTensor().rank() == 2U);
232  BOOST_TEST(indices.minorTensor().size() == 3U * 4U);
233 
234  //
235  // indexing
236  //
237  // BUG the double brace syntax is required to work around clang bug 21629
238  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
239  std::array<char, 3> ii {{ 1, 2, 3 }}; // char is for test; it should be size_t
240 /* TODO
241  BOOST_TEST(indices[0] == 0U);
242  BOOST_TEST(indices[1] == 1U);
243  BOOST_TEST(indices[2] == 2U);
244  BOOST_TEST(indices[3] == 3U);
245  BOOST_TEST(indices[4] == 4U); // no bound check
246 */
247  BOOST_TEST(indices(0, 0, 0) == 0U);
248  BOOST_TEST(indices(1, 2, 3) == 23U);
249  BOOST_TEST(indices(ii.begin()) == 23U);
250  BOOST_CHECK_NO_THROW(indices(1, 3, 1));
251  BOOST_CHECK_NO_THROW(indices(4, 2, 1));
252  BOOST_CHECK_NO_THROW(indices(1, 2, 6));
253  BOOST_CHECK_NO_THROW(indices(7, 6, 6));
254 
255  BOOST_TEST(indices.at(0, 0, 0) == 0U);
256  BOOST_TEST(indices.at(1, 2, 3) == 23U);
257  BOOST_TEST(indices.at(ii.begin()) == 23U);
258  BOOST_CHECK_THROW(indices.at(1, 3, 1), std::out_of_range);
259  BOOST_CHECK_THROW(indices.at(4, 2, 1), std::out_of_range);
260  BOOST_CHECK_THROW(indices.at(1, 2, 6), std::out_of_range);
261  BOOST_CHECK_THROW(indices.at(7, 6, 6), std::out_of_range);
262 
263  BOOST_TEST(indices.has(0, 0, 0));
264  BOOST_TEST(indices.has(1, 2, 3));
265  BOOST_TEST(indices.has(ii.begin()));
266  BOOST_TEST(!indices.has(1, 3, 1));
267  BOOST_TEST(!indices.has(4, 2, 1));
268  BOOST_TEST(!indices.has(1, 2, 6));
269  BOOST_TEST(!indices.has(7, 6, 6));
270 
271  BOOST_TEST( indices.hasIndex<0>(0));
272  BOOST_TEST( indices.hasIndex<0>(1));
273  BOOST_TEST(!indices.hasIndex<0>(2));
274  BOOST_TEST( indices.hasIndex<1>(0));
275  BOOST_TEST( indices.hasIndex<1>(2));
276  BOOST_TEST(!indices.hasIndex<1>(3));
277  BOOST_TEST( indices.hasIndex<2>(0));
278  BOOST_TEST( indices.hasIndex<2>(3));
279  BOOST_TEST(!indices.hasIndex<2>(4));
280 
281  BOOST_TEST(indices.hasLinIndex(0U));
282  BOOST_TEST(indices.hasLinIndex(indices.size() - 1));
283  BOOST_TEST(!indices.hasLinIndex(indices.size()));
284 
285  //
286  // comparisons
287  //
288  // check that the function also works
289  // BUG the double brace syntax is required to work around clang bug 21629
290  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
291  std::array<int, 3> ia {{ 2, 3, 4 }};
292  util::TensorIndices<3> indicesAgain(ia.begin());
293  util::TensorIndices<3> indicesOther = util::makeTensorIndices(2, 3, 5);
294  util::TensorIndices<2> indicesRank = util::makeTensorIndices(2, 3);
295 
296  // check the comparison operators
297  BOOST_TEST((indicesAgain == indices));
298  BOOST_TEST(!(indicesAgain != indices));
299  BOOST_TEST((indicesOther != indices));
300  BOOST_TEST(!(indicesOther == indices));
301  BOOST_TEST((indicesRank != indices));
302  BOOST_TEST(!(indicesRank == indices));
303 
304 } // TensorRank3Test()
util::TensorIndices
Converts a tensor element specification into a linear index.
Definition: TensorIndices.h:46
geo::vect::indices
constexpr std::array< std::size_t, geo::vect::dimension< Vector >)> indices()
Returns a sequence of indices valid for a vector of the specified type.
Definition: geo_vectors_utils.h:2022
util::makeTensorIndices
auto makeTensorIndices(DIMS...dims)
Instantiates a TensorIndices class with the specified dimensions.
Definition: TensorIndices.h:543
void VectorTest ( )

Test for a rank 1 tensor (vector)

Definition at line 40 of file TensorIndices_test.cc.

40  {
41 
42  // indices for a vector of size 4
43  util::TensorIndices<1> const indices{4};
44 
45  //
46  // reflection
47  //
48  BOOST_TEST(indices.dim<0>() == 4U);
49 
50  BOOST_TEST(indices.size<0>() == 4U);
51 
52  BOOST_TEST(indices.size() == 4U);
53 
54  //
55  // indexing
56  //
57  // BUG the double brace syntax is required to work around clang bug 21629
58  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
59  std::array<char, 1> ii {{ 1 }}; // char is for test; it should be size_t
60 /* TODO
61  BOOST_TEST(indices[0] == 0U);
62  BOOST_TEST(indices[1] == 1U);
63  BOOST_TEST(indices[2] == 2U);
64  BOOST_TEST(indices[3] == 3U);
65  BOOST_TEST(indices[4] == 4U); // no bound check
66 */
67  BOOST_TEST(indices(0) == 0U);
68  BOOST_TEST(indices(1) == 1U);
69  BOOST_TEST(indices(ii.begin()) == 1U);
70  BOOST_TEST(indices(2) == 2U);
71  BOOST_TEST(indices(3) == 3U);
72  BOOST_CHECK_NO_THROW(indices(4)); // no bound check
73 
74  BOOST_TEST(indices.at(0) == 0U);
75  BOOST_TEST(indices.at(1) == 1U);
76  BOOST_TEST(indices.at(ii.begin()) == 1U);
77  BOOST_TEST(indices.at(2) == 2U);
78  BOOST_TEST(indices.at(3) == 3U);
79  BOOST_CHECK_THROW(indices.at(4), std::out_of_range);
80 
81  BOOST_TEST(indices.has(0));
82  BOOST_TEST(indices.has(1));
83  BOOST_TEST(indices.has(ii.begin()));
84  BOOST_TEST(indices.has(2));
85  BOOST_TEST(indices.has(3));
86  BOOST_TEST(!indices.has(4));
87 
88  BOOST_TEST( indices.hasIndex<0>(0));
89  BOOST_TEST( indices.hasIndex<0>(1));
90  BOOST_TEST( indices.hasIndex<0>(2));
91  BOOST_TEST( indices.hasIndex<0>(3));
92  BOOST_TEST(!indices.hasIndex<0>(4));
93  BOOST_TEST(!indices.hasIndex<0>(5));
94 
95  BOOST_TEST(indices.hasLinIndex(0U));
96  BOOST_TEST(indices.hasLinIndex(indices.size() - 1));
97  BOOST_TEST(!indices.hasLinIndex(indices.size()));
98 
99  BOOST_TEST(indices.size() == 4U);
100 
101  // check that the function also works
102  // BUG the double brace syntax is required to work around clang bug 21629
103  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
104  std::array<int, 1> ia {{ 4 }};
105  util::TensorIndices<1> indicesAgain(ia.begin());
106  util::TensorIndices<1> indicesOther = util::makeTensorIndices(3);
107  util::TensorIndices<2> indicesRank = util::makeTensorIndices(4, 3);
108 
109  // check the comparison operators
110  BOOST_TEST((indicesAgain == indices));
111  BOOST_TEST(!(indicesAgain != indices));
112  BOOST_TEST((indicesOther != indices));
113  BOOST_TEST(!(indicesOther == indices));
114  BOOST_TEST((indicesRank != indices));
115  BOOST_TEST(!(indicesRank == indices));
116 
117 
118 } // VectorTest()
util::TensorIndices
Converts a tensor element specification into a linear index.
Definition: TensorIndices.h:46
geo::vect::indices
constexpr std::array< std::size_t, geo::vect::dimension< Vector >)> indices()
Returns a sequence of indices valid for a vector of the specified type.
Definition: geo_vectors_utils.h:2022
util::makeTensorIndices
auto makeTensorIndices(DIMS...dims)
Instantiates a TensorIndices class with the specified dimensions.
Definition: TensorIndices.h:543
Generated by   doxygen 1.8.5