1 //=================================================================================================
2 /*!
3 // \file src/mathtest/traits/declstrlowtrait/ClassTest.cpp
4 // \brief Source file for the DeclStrLowTrait class test
5 //
6 // Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
7 //
8 // This file is part of the Blaze library. You can redistribute it and/or modify it under
9 // the terms of the New (Revised) BSD License. Redistribution and use in source and binary
10 // forms, with or without modification, are permitted provided that the following conditions
11 // are met:
12 //
13 // 1. Redistributions of source code must retain the above copyright notice, this list of
14 // conditions and the following disclaimer.
15 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
16 // of conditions and the following disclaimer in the documentation and/or other materials
17 // provided with the distribution.
18 // 3. Neither the names of the Blaze development group nor the names of its contributors
19 // may be used to endorse or promote products derived from this software without specific
20 // prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 // SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 // BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 // DAMAGE.
32 */
33 //=================================================================================================
34
35
36 //*************************************************************************************************
37 // Includes
38 //*************************************************************************************************
39
40 #include <cstdlib>
41 #include <iostream>
42 #include <utility>
43 #include <blaze/math/CompressedMatrix.h>
44 #include <blaze/math/CustomMatrix.h>
45 #include <blaze/math/DynamicMatrix.h>
46 #include <blaze/math/HermitianMatrix.h>
47 #include <blaze/math/HybridMatrix.h>
48 #include <blaze/math/InitializerMatrix.h>
49 #include <blaze/math/LowerMatrix.h>
50 #include <blaze/math/StaticMatrix.h>
51 #include <blaze/math/StrictlyLowerMatrix.h>
52 #include <blaze/math/StrictlyUpperMatrix.h>
53 #include <blaze/math/SymmetricMatrix.h>
54 #include <blaze/math/traits/DeclStrLowTrait.h>
55 #include <blaze/math/typetraits/StorageOrder.h>
56 #include <blaze/math/UpperMatrix.h>
57 #include <blaze/math/ZeroMatrix.h>
58 #include <blaze/util/Complex.h>
59 #include <blaze/util/typetraits/IsSame.h>
60 #include <blaze/util/typetraits/RemoveCVRef.h>
61 #include <blazetest/mathtest/traits/declstrlowtrait/ClassTest.h>
62
63
64 namespace blazetest {
65
66 namespace mathtest {
67
68 namespace traits {
69
70 namespace declstrlowtrait {
71
72 //=================================================================================================
73 //
74 // CONSTRUCTORS
75 //
76 //=================================================================================================
77
78 //*************************************************************************************************
79 /*!\brief Constructor for the DeclStrLowTrait class test.
80 //
81 // \exception std::runtime_error Error detected.
82 */
ClassTest()83 ClassTest::ClassTest()
84 {
85 testMatrixDeclStrLow();
86 }
87 //*************************************************************************************************
88
89
90
91
92 //=================================================================================================
93 //
94 // TEST FUNCTIONS
95 //
96 //=================================================================================================
97
98 //*************************************************************************************************
99 /*!\brief Test of the 'DeclStrLowTrait' class template for matrix operations.
100 //
101 // \return void
102 // \exception std::runtime_error Error detected.
103 //
104 // This function performs a compile time test of the 'DeclStrLowTrait' class template for matrix
105 // operations. In case an error is detected, a compilation error is created.
106 */
testMatrixDeclStrLow()107 void ClassTest::testMatrixDeclStrLow()
108 {
109 using namespace blaze;
110
111
112 // StaticMatrix
113 {
114 {
115 using MT = StaticMatrix<int,3UL,3UL,rowMajor>;
116 using RT = StrictlyLowerMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
117 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
118
119 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
120 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
121 }
122 {
123 using MT = StaticMatrix<int,3UL,3UL,columnMajor>;
124 using RT = StrictlyLowerMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
125 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
126
127 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
128 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
129 }
130 }
131
132 // HybridMatrix
133 {
134 {
135 using MT = HybridMatrix<int,3UL,3UL,rowMajor>;
136 using RT = StrictlyLowerMatrix< HybridMatrix<int,3UL,3UL,rowMajor> >;
137 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
138
139 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
140 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
141 }
142 {
143 using MT = HybridMatrix<int,3UL,3UL,columnMajor>;
144 using RT = StrictlyLowerMatrix< HybridMatrix<int,3UL,3UL,columnMajor> >;
145 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
146
147 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
148 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
149 }
150 }
151
152 // DynamicMatrix
153 {
154 {
155 using MT = DynamicMatrix<int,rowMajor>;
156 using RT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
157 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
158
159 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
160 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
161 }
162 {
163 using MT = DynamicMatrix<int,columnMajor>;
164 using RT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
165 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
166
167 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
168 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
169 }
170 }
171
172 // CustomMatrix
173 {
174 {
175 using MT = CustomMatrix<int,unaligned,unpadded,rowMajor>;
176 using RT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
177 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
178
179 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
180 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
181 }
182 {
183 using MT = CustomMatrix<int,unaligned,unpadded,columnMajor>;
184 using RT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
185 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
186
187 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
188 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
189 }
190 }
191
192 // InitializerMatrix
193 {
194 {
195 using MT = InitializerMatrix<int>;
196 using RT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
197 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
198
199 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
200 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
201 }
202 }
203
204 // CompressedMatrix
205 {
206 {
207 using MT = CompressedMatrix<int,rowMajor>;
208 using RT = StrictlyLowerMatrix< CompressedMatrix<int,rowMajor> >;
209 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
210
211 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
212 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
213 }
214 {
215 using MT = CompressedMatrix<int,columnMajor>;
216 using RT = StrictlyLowerMatrix< CompressedMatrix<int,columnMajor> >;
217 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
218
219 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
220 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
221 }
222 }
223
224 // ZeroMatrix
225 {
226 {
227 using MT = ZeroMatrix<int,rowMajor>;
228 using RT = ZeroMatrix<int,rowMajor>;
229 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
230
231 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
232 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
233 }
234 {
235 using MT = ZeroMatrix<int,columnMajor>;
236 using RT = ZeroMatrix<int,columnMajor>;
237 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
238
239 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
240 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
241 }
242 }
243
244 // SymmetricMatrix (real)
245 {
246 {
247 using MT = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
248 using RT = ZeroMatrix<int,rowMajor>;
249 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
250
251 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
252 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
253 }
254 {
255 using MT = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
256 using RT = ZeroMatrix<int,columnMajor>;
257 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
258
259 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
260 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
261 }
262 }
263
264 // SymmetricMatrix (complex)
265 {
266 {
267 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
268 using RT = ZeroMatrix<complex<int>,rowMajor>;
269 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
270
271 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
272 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
273 }
274 {
275 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
276 using RT = ZeroMatrix<complex<int>,columnMajor>;
277 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
278
279 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
280 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
281 }
282 }
283
284 // HermitianMatrix (symmetric)
285 {
286 {
287 using MT = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
288 using RT = ZeroMatrix<int,rowMajor>;
289 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
290
291 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
292 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
293 }
294 {
295 using MT = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
296 using RT = ZeroMatrix<int,columnMajor>;
297 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
298
299 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
300 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
301 }
302 }
303
304 // HermitianMatrix (Hermitian)
305 {
306 {
307 using MT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
308 using RT = ZeroMatrix<complex<int>,rowMajor>;
309 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
310
311 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
312 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
313 }
314 {
315 using MT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
316 using RT = ZeroMatrix<complex<int>,columnMajor>;
317 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
318
319 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
320 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
321 }
322 }
323
324 // LowerMatrix
325 {
326 {
327 using MT = LowerMatrix< DynamicMatrix<int,rowMajor> >;
328 using RT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
329 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
330
331 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
332 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
333 }
334 {
335 using MT = LowerMatrix< DynamicMatrix<int,columnMajor> >;
336 using RT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
337 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
338
339 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
340 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
341 }
342 }
343
344 // StrictlyLowerMatrix
345 {
346 {
347 using MT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
348 using RT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
349 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
350
351 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
352 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
353 }
354 {
355 using MT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
356 using RT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
357 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
358
359 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
360 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
361 }
362 }
363
364 // UpperMatrix
365 {
366 {
367 using MT = UpperMatrix< DynamicMatrix<int,rowMajor> >;
368 using RT = ZeroMatrix<int,rowMajor>;
369 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
370
371 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
372 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
373 }
374 {
375 using MT = UpperMatrix< DynamicMatrix<int,columnMajor> >;
376 using RT = ZeroMatrix<int,columnMajor>;
377 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
378
379 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
380 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
381 }
382 }
383
384 // StrictlyUpperMatrix
385 {
386 {
387 using MT = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
388 using RT = ZeroMatrix<int,rowMajor>;
389 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
390
391 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
392 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
393 }
394 {
395 using MT = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
396 using RT = ZeroMatrix<int,columnMajor>;
397 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
398
399 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
400 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
401 }
402 }
403
404 // DiagonalMatrix
405 {
406 {
407 using MT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
408 using RT = ZeroMatrix<int,rowMajor>;
409 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
410
411 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
412 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
413 }
414 {
415 using MT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
416 using RT = ZeroMatrix<int,columnMajor>;
417 static_assert( IsSame_v< DeclStrLowTrait_t<MT>, RT >, "Non-matching type detected" );
418
419 using Expr = RemoveCVRef_t< decltype( declstrlow( std::declval<MT>() ) ) >;
420 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
421 }
422 }
423 }
424 //*************************************************************************************************
425
426 } // namespace declstrlowtrait
427
428 } // namespace traits
429
430 } // namespace mathtest
431
432 } // namespace blazetest
433
434
435
436
437 //=================================================================================================
438 //
439 // MAIN FUNCTION
440 //
441 //=================================================================================================
442
443 //*************************************************************************************************
main()444 int main()
445 {
446 std::cout << " Running DeclStrLowTrait class test..." << std::endl;
447
448 try
449 {
450 RUN_DECLSTRLOWTRAIT_CLASS_TEST;
451 }
452 catch( std::exception& ex ) {
453 std::cerr << "\n\n ERROR DETECTED during DeclStrLowTrait class test:\n"
454 << ex.what() << "\n";
455 return EXIT_FAILURE;
456 }
457
458 return EXIT_SUCCESS;
459 }
460 //*************************************************************************************************
461