1 //=================================================================================================
2 /*!
3 // \file src/mathtest/traits/decldiagtrait/ClassTest.cpp
4 // \brief Source file for the DeclDiagTrait 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/IdentityMatrix.h>
49 #include <blaze/math/InitializerMatrix.h>
50 #include <blaze/math/LowerMatrix.h>
51 #include <blaze/math/StaticMatrix.h>
52 #include <blaze/math/StrictlyLowerMatrix.h>
53 #include <blaze/math/StrictlyUpperMatrix.h>
54 #include <blaze/math/SymmetricMatrix.h>
55 #include <blaze/math/traits/DeclDiagTrait.h>
56 #include <blaze/math/typetraits/StorageOrder.h>
57 #include <blaze/math/UniformMatrix.h>
58 #include <blaze/math/UniLowerMatrix.h>
59 #include <blaze/math/UniUpperMatrix.h>
60 #include <blaze/math/UpperMatrix.h>
61 #include <blaze/math/ZeroMatrix.h>
62 #include <blaze/util/Complex.h>
63 #include <blaze/util/typetraits/IsSame.h>
64 #include <blaze/util/typetraits/RemoveCVRef.h>
65 #include <blazetest/mathtest/traits/decldiagtrait/ClassTest.h>
66
67
68 namespace blazetest {
69
70 namespace mathtest {
71
72 namespace traits {
73
74 namespace decldiagtrait {
75
76 //=================================================================================================
77 //
78 // CONSTRUCTORS
79 //
80 //=================================================================================================
81
82 //*************************************************************************************************
83 /*!\brief Constructor for the DeclDiagTrait class test.
84 //
85 // \exception std::runtime_error Error detected.
86 */
ClassTest()87 ClassTest::ClassTest()
88 {
89 testMatrixDeclDiag();
90 }
91 //*************************************************************************************************
92
93
94
95
96 //=================================================================================================
97 //
98 // TEST FUNCTIONS
99 //
100 //=================================================================================================
101
102 //*************************************************************************************************
103 /*!\brief Test of the 'DeclDiagTrait' class template for matrix operations.
104 //
105 // \return void
106 // \exception std::runtime_error Error detected.
107 //
108 // This function performs a compile time test of the 'DeclDiagTrait' class template for matrix
109 // operations. In case an error is detected, a compilation error is created.
110 */
testMatrixDeclDiag()111 void ClassTest::testMatrixDeclDiag()
112 {
113 using namespace blaze;
114
115
116 // StaticMatrix
117 {
118 {
119 using MT = StaticMatrix<int,3UL,3UL,rowMajor>;
120 using RT = DiagonalMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
121 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
122
123 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
124 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
125 }
126 {
127 using MT = StaticMatrix<int,3UL,3UL,columnMajor>;
128 using RT = DiagonalMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
129 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
130
131 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
132 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
133 }
134 }
135
136 // HybridMatrix
137 {
138 {
139 using MT = HybridMatrix<int,3UL,3UL,rowMajor>;
140 using RT = DiagonalMatrix< HybridMatrix<int,3UL,3UL,rowMajor> >;
141 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
142
143 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
144 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
145 }
146 {
147 using MT = HybridMatrix<int,3UL,3UL,columnMajor>;
148 using RT = DiagonalMatrix< HybridMatrix<int,3UL,3UL,columnMajor> >;
149 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
150
151 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
152 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
153 }
154 }
155
156 // DynamicMatrix
157 {
158 {
159 using MT = DynamicMatrix<int,rowMajor>;
160 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
161 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
162
163 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
164 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
165 }
166 {
167 using MT = DynamicMatrix<int,columnMajor>;
168 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
169 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
170
171 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
172 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
173 }
174 }
175
176 // CustomMatrix
177 {
178 {
179 using MT = CustomMatrix<int,unaligned,unpadded,rowMajor>;
180 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
181 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
182
183 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
184 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
185 }
186 {
187 using MT = CustomMatrix<int,unaligned,unpadded,columnMajor>;
188 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
189 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
190
191 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
192 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
193 }
194 }
195
196 // UniformMatrix
197 {
198 {
199 using MT = UniformMatrix<int,rowMajor>;
200 using RT = DiagonalMatrix< UniformMatrix<int,rowMajor> >;
201 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
202
203 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
204 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
205 }
206 {
207 using MT = UniformMatrix<int,columnMajor>;
208 using RT = DiagonalMatrix< UniformMatrix<int,columnMajor> >;
209 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
210
211 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
212 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
213 }
214 }
215
216 // InitializerMatrix
217 {
218 {
219 using MT = InitializerMatrix<int>;
220 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
221 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
222
223 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
224 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
225 }
226 }
227
228 // CompressedMatrix
229 {
230 {
231 using MT = CompressedMatrix<int,rowMajor>;
232 using RT = DiagonalMatrix< CompressedMatrix<int,rowMajor> >;
233 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
234
235 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
236 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
237 }
238 {
239 using MT = CompressedMatrix<int,columnMajor>;
240 using RT = DiagonalMatrix< CompressedMatrix<int,columnMajor> >;
241 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
242
243 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
244 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
245 }
246 }
247
248 // IdentityMatrix
249 {
250 {
251 using MT = IdentityMatrix<int,rowMajor>;
252 using RT = IdentityMatrix<int,rowMajor>;
253 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
254
255 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
256 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
257 }
258 {
259 using MT = IdentityMatrix<int,columnMajor>;
260 using RT = IdentityMatrix<int,columnMajor>;
261 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
262
263 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
264 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
265 }
266 }
267
268 // ZeroMatrix
269 {
270 {
271 using MT = ZeroMatrix<int,rowMajor>;
272 using RT = DiagonalMatrix< ZeroMatrix<int,rowMajor> >;
273 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
274
275 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
276 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
277 }
278 {
279 using MT = ZeroMatrix<int,columnMajor>;
280 using RT = DiagonalMatrix< ZeroMatrix<int,columnMajor> >;
281 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
282
283 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
284 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
285 }
286 }
287
288 // SymmetricMatrix (real)
289 {
290 {
291 using MT = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
292 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
293 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
294
295 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
296 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
297 }
298 {
299 using MT = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
300 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
301 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
302
303 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
304 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
305 }
306 }
307
308 // SymmetricMatrix (complex)
309 {
310 {
311 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
312 using RT = DiagonalMatrix< DynamicMatrix<complex<int>,rowMajor> >;
313 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
314
315 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
316 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
317 }
318 {
319 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
320 using RT = DiagonalMatrix< DynamicMatrix<complex<int>,columnMajor> >;
321 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
322
323 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
324 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
325 }
326 }
327
328 // HermitianMatrix (symmetric)
329 {
330 {
331 using MT = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
332 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
333 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
334
335 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
336 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
337 }
338 {
339 using MT = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
340 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
341 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
342
343 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
344 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
345 }
346 }
347
348 // HermitianMatrix (Hermitian)
349 {
350 {
351 using MT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
352 using RT = DiagonalMatrix< DynamicMatrix<complex<int>,rowMajor> >;
353 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
354
355 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
356 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
357 }
358 {
359 using MT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
360 using RT = DiagonalMatrix< DynamicMatrix<complex<int>,columnMajor> >;
361 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
362
363 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
364 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
365 }
366 }
367
368 // LowerMatrix
369 {
370 {
371 using MT = LowerMatrix< DynamicMatrix<int,rowMajor> >;
372 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
373 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
374
375 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
376 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
377 }
378 {
379 using MT = LowerMatrix< DynamicMatrix<int,columnMajor> >;
380 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
381 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
382
383 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
384 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
385 }
386 }
387
388 // UniLowerMatrix
389 {
390 {
391 using MT = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
392 using RT = IdentityMatrix<int,rowMajor>;
393 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
394
395 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
396 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
397 }
398 {
399 using MT = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
400 using RT = IdentityMatrix<int,columnMajor>;
401 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
402
403 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
404 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
405 }
406 }
407
408 // StrictlyLowerMatrix
409 {
410 {
411 using MT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
412 using RT = ZeroMatrix<int,rowMajor>;
413 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
414
415 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
416 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
417 }
418 {
419 using MT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
420 using RT = ZeroMatrix<int,columnMajor>;
421 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
422
423 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
424 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
425 }
426 }
427
428 // UpperMatrix
429 {
430 {
431 using MT = UpperMatrix< DynamicMatrix<int,rowMajor> >;
432 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
433 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
434
435 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
436 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
437 }
438 {
439 using MT = UpperMatrix< DynamicMatrix<int,columnMajor> >;
440 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
441 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
442
443 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
444 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
445 }
446 }
447
448 // UniUpperMatrix
449 {
450 {
451 using MT = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
452 using RT = IdentityMatrix<int,rowMajor>;
453 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
454
455 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
456 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
457 }
458 {
459 using MT = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
460 using RT = IdentityMatrix<int,columnMajor>;
461 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
462
463 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
464 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
465 }
466 }
467
468 // StrictlyUpperMatrix
469 {
470 {
471 using MT = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
472 using RT = ZeroMatrix<int,rowMajor>;
473 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
474
475 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
476 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
477 }
478 {
479 using MT = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
480 using RT = ZeroMatrix<int,columnMajor>;
481 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
482
483 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
484 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
485 }
486 }
487
488 // DiagonalMatrix
489 {
490 {
491 using MT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
492 using RT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
493 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
494
495 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
496 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
497 }
498 {
499 using MT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
500 using RT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
501 static_assert( IsSame_v< DeclDiagTrait_t<MT>, RT >, "Non-matching type detected" );
502
503 using Expr = RemoveCVRef_t< decltype( decldiag( std::declval<MT>() ) ) >;
504 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
505 }
506 }
507 }
508 //*************************************************************************************************
509
510 } // namespace decldiagtrait
511
512 } // namespace traits
513
514 } // namespace mathtest
515
516 } // namespace blazetest
517
518
519
520
521 //=================================================================================================
522 //
523 // MAIN FUNCTION
524 //
525 //=================================================================================================
526
527 //*************************************************************************************************
main()528 int main()
529 {
530 std::cout << " Running DeclDiagTrait class test..." << std::endl;
531
532 try
533 {
534 RUN_DECLDIAGTRAIT_CLASS_TEST;
535 }
536 catch( std::exception& ex ) {
537 std::cerr << "\n\n ERROR DETECTED during DeclDiagTrait class test:\n"
538 << ex.what() << "\n";
539 return EXIT_FAILURE;
540 }
541
542 return EXIT_SUCCESS;
543 }
544 //*************************************************************************************************
545