1 //=================================================================================================
2 /*!
3 // \file src/mathtest/traits/submatrixtrait/ClassTest.cpp
4 // \brief Source file for the SubmatrixTrait 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/DiagonalMatrix.h>
46 #include <blaze/math/DynamicMatrix.h>
47 #include <blaze/math/HermitianMatrix.h>
48 #include <blaze/math/HybridMatrix.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/SubmatrixTrait.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/Views.h>
62 #include <blaze/math/ZeroMatrix.h>
63 #include <blaze/util/typetraits/IsSame.h>
64 #include <blaze/util/typetraits/RemoveCVRef.h>
65 #include <blazetest/mathtest/traits/submatrixtrait/ClassTest.h>
66
67
68 namespace blazetest {
69
70 namespace mathtest {
71
72 namespace traits {
73
74 namespace submatrixtrait {
75
76 //=================================================================================================
77 //
78 // CONSTRUCTORS
79 //
80 //=================================================================================================
81
82 //*************************************************************************************************
83 /*!\brief Constructor for the SubmatrixTrait class test.
84 //
85 // \exception std::runtime_error Error detected.
86 */
ClassTest()87 ClassTest::ClassTest()
88 {
89 testSubmatrixOperation();
90 }
91 //*************************************************************************************************
92
93
94
95
96 //=================================================================================================
97 //
98 // TEST FUNCTIONS
99 //
100 //=================================================================================================
101
102 //*************************************************************************************************
103 /*!\brief Test of the 'SubmatrixTrait' class template for submatrix operations.
104 //
105 // \return void
106 // \exception std::runtime_error Error detected.
107 //
108 // This function performs a compile time test of the 'SubmatrixTrait' class template for submatrix
109 // operations. In case an error is detected, a compilation error is created.
110 */
testSubmatrixOperation()111 void ClassTest::testSubmatrixOperation()
112 {
113 using namespace blaze;
114
115
116 // StaticMatrix
117 {
118 {
119 using MT = StaticMatrix<int,3UL,5UL,rowMajor>;
120 using RT = HybridMatrix<int,3UL,5UL,rowMajor>;
121 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
122
123 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
124 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
125 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
126 }
127 {
128 using MT = StaticMatrix<int,3UL,5UL,columnMajor>;
129 using RT = HybridMatrix<int,3UL,5UL,columnMajor>;
130 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
131
132 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
133 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
134 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
135 }
136 {
137 using MT = StaticMatrix<int,3UL,5UL,rowMajor>;
138 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
139 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
140
141 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
142 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
143 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
144 }
145 {
146 using MT = StaticMatrix<int,3UL,5UL,columnMajor>;
147 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
148 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
149
150 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
151 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
152 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
153 }
154 }
155
156 // HybridMatrix
157 {
158 {
159 using MT = HybridMatrix<int,3UL,5UL,rowMajor>;
160 using RT = HybridMatrix<int,3UL,5UL,rowMajor>;
161 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
162
163 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
164 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
165 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
166 }
167 {
168 using MT = HybridMatrix<int,3UL,5UL,columnMajor>;
169 using RT = HybridMatrix<int,3UL,5UL,columnMajor>;
170 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
171
172 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
173 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
174 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
175 }
176 {
177 using MT = HybridMatrix<int,3UL,5UL,rowMajor>;
178 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
179 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
180
181 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
182 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
183 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
184 }
185 {
186 using MT = HybridMatrix<int,3UL,5UL,columnMajor>;
187 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
188 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
189
190 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
191 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
192 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
193 }
194 }
195
196 // DynamicMatrix
197 {
198 {
199 using MT = DynamicMatrix<int,rowMajor>;
200 using RT = DynamicMatrix<int,rowMajor>;
201 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
202
203 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
204 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
205 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
206 }
207 {
208 using MT = DynamicMatrix<int,columnMajor>;
209 using RT = DynamicMatrix<int,columnMajor>;
210 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
211
212 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
213 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
214 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
215 }
216 {
217 using MT = DynamicMatrix<int,rowMajor>;
218 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
219 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
220
221 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
222 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
223 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
224 }
225 {
226 using MT = DynamicMatrix<int,columnMajor>;
227 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
228 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
229
230 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
231 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
232 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
233 }
234 }
235
236 // CustomMatrix
237 {
238 {
239 using MT = CustomMatrix<int,unaligned,unpadded,rowMajor>;
240 using RT = DynamicMatrix<int,rowMajor>;
241 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
242
243 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
244 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
245 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
246 }
247 {
248 using MT = CustomMatrix<int,unaligned,unpadded,columnMajor>;
249 using RT = DynamicMatrix<int,columnMajor>;
250 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
251
252 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
253 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
254 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
255 }
256 {
257 using MT = CustomMatrix<int,unaligned,unpadded,rowMajor>;
258 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
259 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
260
261 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
262 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
263 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
264 }
265 {
266 using MT = CustomMatrix<int,unaligned,unpadded,columnMajor>;
267 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
268 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
269
270 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
271 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
272 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
273 }
274 }
275
276 // UniformMatrix
277 {
278 {
279 using MT = UniformMatrix<int,rowMajor>;
280 using RT = UniformMatrix<int,rowMajor>;
281 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
282
283 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
284 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
285 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
286 }
287 {
288 using MT = UniformMatrix<int,columnMajor>;
289 using RT = UniformMatrix<int,columnMajor>;
290 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
291
292 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
293 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
294 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
295 }
296 {
297 using MT = UniformMatrix<int,rowMajor>;
298 using RT = UniformMatrix<int,rowMajor>;
299 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
300
301 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
302 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
303 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
304 }
305 {
306 using MT = UniformMatrix<int,columnMajor>;
307 using RT = UniformMatrix<int,columnMajor>;
308 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
309
310 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
311 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
312 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
313 }
314 }
315
316 // InitializerMatrix
317 {
318 {
319 using MT = InitializerMatrix<int>;
320 using RT = DynamicMatrix<int,rowMajor>;
321 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
322
323 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
324 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
325 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
326 }
327 {
328 using MT = InitializerMatrix<int>;
329 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
330 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
331
332 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
333 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
334 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
335 }
336 }
337
338 // CompressedMatrix
339 {
340 {
341 using MT = CompressedMatrix<int,rowMajor>;
342 using RT = CompressedMatrix<int,rowMajor>;
343 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
344
345 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
346 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
347 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
348 }
349 {
350 using MT = CompressedMatrix<int,columnMajor>;
351 using RT = CompressedMatrix<int,columnMajor>;
352 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
353
354 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
355 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
356 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
357 }
358 {
359 using MT = CompressedMatrix<int,rowMajor>;
360 using RT = CompressedMatrix<int,rowMajor>;
361 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
362
363 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
364 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
365 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
366 }
367 {
368 using MT = CompressedMatrix<int,columnMajor>;
369 using RT = CompressedMatrix<int,columnMajor>;
370 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
371
372 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
373 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
374 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
375 }
376 }
377
378 // IdentityMatrix
379 {
380 {
381 using MT = IdentityMatrix<int,rowMajor>;
382 using RT = CompressedMatrix<int,rowMajor>;
383 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
384
385 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
386 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
387 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
388 }
389 {
390 using MT = IdentityMatrix<int,columnMajor>;
391 using RT = CompressedMatrix<int,columnMajor>;
392 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
393
394 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
395 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
396 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
397 }
398 {
399 using MT = IdentityMatrix<int,rowMajor>;
400 using RT = CompressedMatrix<int,rowMajor>;
401 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
402
403 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
404 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
405 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
406 }
407 {
408 using MT = IdentityMatrix<int,columnMajor>;
409 using RT = CompressedMatrix<int,columnMajor>;
410 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
411
412 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
413 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
414 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
415 }
416 }
417
418 // ZeroMatrix
419 {
420 {
421 using MT = ZeroMatrix<int,rowMajor>;
422 using RT = ZeroMatrix<int,rowMajor>;
423 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
424
425 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
426 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
427 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
428 }
429 {
430 using MT = ZeroMatrix<int,columnMajor>;
431 using RT = ZeroMatrix<int,columnMajor>;
432 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
433
434 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
435 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
436 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
437 }
438 {
439 using MT = ZeroMatrix<int,rowMajor>;
440 using RT = ZeroMatrix<int,rowMajor>;
441 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
442
443 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
444 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
445 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
446 }
447 {
448 using MT = ZeroMatrix<int,columnMajor>;
449 using RT = ZeroMatrix<int,columnMajor>;
450 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
451
452 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
453 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
454 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
455 }
456 }
457
458 // SymmetricMatrix<DynamicMatrix> (real)
459 {
460 {
461 using MT = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
462 using RT = DynamicMatrix<int,rowMajor>;
463 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
464
465 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
466 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
467 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
468 }
469 {
470 using MT = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
471 using RT = DynamicMatrix<int,columnMajor>;
472 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
473
474 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
475 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
476 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
477 }
478 {
479 using MT = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
480 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
481 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
482
483 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
484 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
485 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
486 }
487 {
488 using MT = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
489 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
490 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
491
492 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
493 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
494 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
495 }
496 {
497 using MT = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
498 using RT = SymmetricMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
499 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
500
501 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
502 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
503 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
504 }
505 {
506 using MT = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
507 using RT = SymmetricMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
508 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
509
510 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
511 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
512 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
513 }
514 }
515
516 // SymmetricMatrix<DynamicMatrix> (complex)
517 {
518 {
519 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
520 using RT = DynamicMatrix<complex<int>,rowMajor>;
521 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
522
523 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
524 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
525 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
526 }
527 {
528 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
529 using RT = DynamicMatrix<complex<int>,columnMajor>;
530 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
531
532 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
533 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
534 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
535 }
536 {
537 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
538 using RT = StaticMatrix<complex<int>,2UL,3UL,rowMajor>;
539 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
540
541 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
542 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
543 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
544 }
545 {
546 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
547 using RT = StaticMatrix<complex<int>,2UL,3UL,columnMajor>;
548 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
549
550 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
551 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
552 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
553 }
554 {
555 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
556 using RT = SymmetricMatrix< StaticMatrix<complex<int>,3UL,3UL,rowMajor> >;
557 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
558
559 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
560 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
561 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
562 }
563 {
564 using MT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
565 using RT = SymmetricMatrix< StaticMatrix<complex<int>,3UL,3UL,columnMajor> >;
566 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
567
568 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
569 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
570 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
571 }
572 }
573
574 // SymmetricMatrix<UniformMatrix> (real)
575 {
576 {
577 using MT = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
578 using RT = UniformMatrix<int,rowMajor>;
579 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
580
581 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
582 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
583 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
584 }
585 {
586 using MT = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
587 using RT = UniformMatrix<int,columnMajor>;
588 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
589
590 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
591 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
592 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
593 }
594 {
595 using MT = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
596 using RT = UniformMatrix<int,rowMajor>;
597 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
598
599 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
600 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
601 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
602 }
603 {
604 using MT = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
605 using RT = UniformMatrix<int,columnMajor>;
606 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
607
608 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
609 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
610 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
611 }
612 {
613 using MT = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
614 using RT = UniformMatrix<int,rowMajor>;
615 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
616
617 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
618 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
619 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
620 }
621 {
622 using MT = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
623 using RT = UniformMatrix<int,columnMajor>;
624 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
625
626 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
627 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
628 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
629 }
630 }
631
632 // SymmetricMatrix<ZeroMatrix> (real)
633 {
634 {
635 using MT = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
636 using RT = ZeroMatrix<int,rowMajor>;
637 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
638
639 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
640 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
641 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
642 }
643 {
644 using MT = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
645 using RT = ZeroMatrix<int,columnMajor>;
646 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
647
648 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
649 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
650 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
651 }
652 {
653 using MT = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
654 using RT = ZeroMatrix<int,rowMajor>;
655 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
656
657 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
658 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
659 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
660 }
661 {
662 using MT = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
663 using RT = ZeroMatrix<int,columnMajor>;
664 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
665
666 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
667 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
668 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
669 }
670 {
671 using MT = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
672 using RT = ZeroMatrix<int,rowMajor>;
673 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
674
675 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
676 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
677 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
678 }
679 {
680 using MT = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
681 using RT = ZeroMatrix<int,columnMajor>;
682 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
683
684 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
685 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
686 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
687 }
688 }
689
690 // HermitianMatrix<DynamicMatrix> (symmetric)
691 {
692 {
693 using MT = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
694 using RT = DynamicMatrix<int,rowMajor>;
695 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
696
697 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
698 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
699 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
700 }
701 {
702 using MT = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
703 using RT = DynamicMatrix<int,columnMajor>;
704 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
705
706 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
707 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
708 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
709 }
710 {
711 using MT = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
712 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
713 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
714
715 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
716 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
717 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
718 }
719 {
720 using MT = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
721 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
722 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
723
724 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
725 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
726 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
727 }
728 {
729 using MT = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
730 using RT = SymmetricMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
731 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
732
733 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
734 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
735 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
736 }
737 {
738 using MT = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
739 using RT = SymmetricMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
740 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
741
742 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
743 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
744 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
745 }
746 }
747
748 // HermitianMatrix<DynamicMatrix> (Hermitian)
749 {
750 {
751 using MT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
752 using RT = DynamicMatrix<complex<int>,rowMajor>;
753 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
754
755 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
756 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
757 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
758 }
759 {
760 using MT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
761 using RT = DynamicMatrix<complex<int>,columnMajor>;
762 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
763
764 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
765 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
766 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
767 }
768 {
769 using MT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
770 using RT = StaticMatrix<complex<int>,2UL,3UL,rowMajor>;
771 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
772
773 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
774 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
775 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
776 }
777 {
778 using MT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
779 using RT = StaticMatrix<complex<int>,2UL,3UL,columnMajor>;
780 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
781
782 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
783 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
784 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
785 }
786 {
787 using MT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
788 using RT = HermitianMatrix< StaticMatrix<complex<int>,3UL,3UL,rowMajor> >;
789 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
790
791 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
792 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
793 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
794 }
795 {
796 using MT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
797 using RT = HermitianMatrix< StaticMatrix<complex<int>,3UL,3UL,columnMajor> >;
798 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
799
800 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
801 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
802 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
803 }
804 }
805
806 // LowerMatrix<DynamicMatrix>
807 {
808 {
809 using MT = LowerMatrix< DynamicMatrix<int,rowMajor> >;
810 using RT = DynamicMatrix<int,rowMajor>;
811 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
812
813 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
814 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
815 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
816 }
817 {
818 using MT = LowerMatrix< DynamicMatrix<int,columnMajor> >;
819 using RT = DynamicMatrix<int,columnMajor>;
820 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
821
822 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
823 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
824 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
825 }
826 {
827 using MT = LowerMatrix< DynamicMatrix<int,rowMajor> >;
828 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
829 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
830
831 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
832 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
833 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
834 }
835 {
836 using MT = LowerMatrix< DynamicMatrix<int,columnMajor> >;
837 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
838 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
839
840 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
841 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
842 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
843 }
844 {
845 using MT = LowerMatrix< DynamicMatrix<int,rowMajor> >;
846 using RT = LowerMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
847 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
848
849 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
850 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
851 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
852 }
853 {
854 using MT = LowerMatrix< DynamicMatrix<int,columnMajor> >;
855 using RT = LowerMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
856 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
857
858 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
859 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
860 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
861 }
862 }
863
864 // UniLowerMatrix<DynamicMatrix>
865 {
866 {
867 using MT = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
868 using RT = DynamicMatrix<int,rowMajor>;
869 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
870
871 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
872 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
873 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
874 }
875 {
876 using MT = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
877 using RT = DynamicMatrix<int,columnMajor>;
878 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
879
880 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
881 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
882 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
883 }
884 {
885 using MT = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
886 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
887 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
888
889 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
890 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
891 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
892 }
893 {
894 using MT = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
895 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
896 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
897
898 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
899 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
900 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
901 }
902 {
903 using MT = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
904 using RT = UniLowerMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
905 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
906
907 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
908 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
909 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
910 }
911 {
912 using MT = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
913 using RT = UniLowerMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
914 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
915
916 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
917 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
918 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
919 }
920 }
921
922 // StrictlyLowerMatrix<DynamicMatrix>
923 {
924 {
925 using MT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
926 using RT = DynamicMatrix<int,rowMajor>;
927 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
928
929 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
930 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
931 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
932 }
933 {
934 using MT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
935 using RT = DynamicMatrix<int,columnMajor>;
936 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
937
938 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
939 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
940 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
941 }
942 {
943 using MT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
944 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
945 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
946
947 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
948 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
949 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
950 }
951 {
952 using MT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
953 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
954 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
955
956 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
957 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
958 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
959 }
960 {
961 using MT = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
962 using RT = StrictlyLowerMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
963 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
964
965 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
966 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
967 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
968 }
969 {
970 using MT = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
971 using RT = StrictlyLowerMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
972 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
973
974 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
975 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
976 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
977 }
978 }
979
980 // UpperMatrix<DynamicMatrix>
981 {
982 {
983 using MT = UpperMatrix< DynamicMatrix<int,rowMajor> >;
984 using RT = DynamicMatrix<int,rowMajor>;
985 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
986
987 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
988 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
989 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
990 }
991 {
992 using MT = UpperMatrix< DynamicMatrix<int,columnMajor> >;
993 using RT = DynamicMatrix<int,columnMajor>;
994 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
995
996 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
997 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
998 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
999 }
1000 {
1001 using MT = UpperMatrix< DynamicMatrix<int,rowMajor> >;
1002 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
1003 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1004
1005 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1006 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1007 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1008 }
1009 {
1010 using MT = UpperMatrix< DynamicMatrix<int,columnMajor> >;
1011 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
1012 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1013
1014 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1015 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1016 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1017 }
1018 {
1019 using MT = UpperMatrix< DynamicMatrix<int,rowMajor> >;
1020 using RT = UpperMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
1021 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1022
1023 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1024 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1025 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1026 }
1027 {
1028 using MT = UpperMatrix< DynamicMatrix<int,columnMajor> >;
1029 using RT = UpperMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
1030 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1031
1032 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1033 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1034 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1035 }
1036 }
1037
1038 // UniUpperMatrix<DynamicMatrix>
1039 {
1040 {
1041 using MT = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
1042 using RT = DynamicMatrix<int,rowMajor>;
1043 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
1044
1045 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
1046 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1047 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1048 }
1049 {
1050 using MT = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
1051 using RT = DynamicMatrix<int,columnMajor>;
1052 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
1053
1054 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
1055 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1056 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1057 }
1058 {
1059 using MT = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
1060 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
1061 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1062
1063 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1064 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1065 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1066 }
1067 {
1068 using MT = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
1069 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
1070 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1071
1072 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1073 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1074 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1075 }
1076 {
1077 using MT = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
1078 using RT = UniUpperMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
1079 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1080
1081 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1082 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1083 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1084 }
1085 {
1086 using MT = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
1087 using RT = UniUpperMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
1088 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1089
1090 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1091 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1092 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1093 }
1094 }
1095
1096 // StrictlyUpperMatrix<DynamicMatrix>
1097 {
1098 {
1099 using MT = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
1100 using RT = DynamicMatrix<int,rowMajor>;
1101 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
1102
1103 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
1104 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1105 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1106 }
1107 {
1108 using MT = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
1109 using RT = DynamicMatrix<int,columnMajor>;
1110 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
1111
1112 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
1113 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1114 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1115 }
1116 {
1117 using MT = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
1118 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
1119 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1120
1121 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1122 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1123 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1124 }
1125 {
1126 using MT = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
1127 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
1128 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1129
1130 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1131 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1132 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1133 }
1134 {
1135 using MT = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
1136 using RT = StrictlyUpperMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
1137 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1138
1139 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1140 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1141 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1142 }
1143 {
1144 using MT = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
1145 using RT = StrictlyUpperMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
1146 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1147
1148 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1149 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1150 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1151 }
1152 }
1153
1154 // DiagonalMatrix<DynamicMatrix>
1155 {
1156 {
1157 using MT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
1158 using RT = DynamicMatrix<int,rowMajor>;
1159 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
1160
1161 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
1162 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1163 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1164 }
1165 {
1166 using MT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
1167 using RT = DynamicMatrix<int,columnMajor>;
1168 static_assert( IsSame_v< SubmatrixTrait_t<MT>, RT >, "Non-matching type detected" );
1169
1170 using Expr = RemoveCVRef_t< decltype( submatrix( std::declval<MT>(), 0UL, 1UL, 2UL, 3UL ) ) >;
1171 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1172 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1173 }
1174 {
1175 using MT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
1176 using RT = StaticMatrix<int,2UL,3UL,rowMajor>;
1177 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1178
1179 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1180 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1181 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1182 }
1183 {
1184 using MT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
1185 using RT = StaticMatrix<int,2UL,3UL,columnMajor>;
1186 static_assert( IsSame_v< SubmatrixTrait_t<MT,0UL,1UL,2UL,3UL>, RT >, "Non-matching type detected" );
1187
1188 using Expr = RemoveCVRef_t< decltype( submatrix<0UL,1UL,2UL,3UL>( std::declval<MT>() ) ) >;
1189 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1190 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1191 }
1192 {
1193 using MT = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
1194 using RT = DiagonalMatrix< StaticMatrix<int,3UL,3UL,rowMajor> >;
1195 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1196
1197 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1198 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1199 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1200 }
1201 {
1202 using MT = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
1203 using RT = DiagonalMatrix< StaticMatrix<int,3UL,3UL,columnMajor> >;
1204 static_assert( IsSame_v< SubmatrixTrait_t<MT,1UL,1UL,3UL,3UL>, RT >, "Non-matching type detected" );
1205
1206 using Expr = RemoveCVRef_t< decltype( submatrix<1UL,1UL,3UL,3UL>( std::declval<MT>() ) ) >;
1207 static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1208 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1209 }
1210 }
1211 }
1212 //*************************************************************************************************
1213
1214 } // namespace submatrixtrait
1215
1216 } // namespace traits
1217
1218 } // namespace mathtest
1219
1220 } // namespace blazetest
1221
1222
1223
1224
1225 //=================================================================================================
1226 //
1227 // MAIN FUNCTION
1228 //
1229 //=================================================================================================
1230
1231 //*************************************************************************************************
main()1232 int main()
1233 {
1234 std::cout << " Running SubmatrixTrait class test..." << std::endl;
1235
1236 try
1237 {
1238 RUN_SUBMATRIXTRAIT_CLASS_TEST;
1239 }
1240 catch( std::exception& ex ) {
1241 std::cerr << "\n\n ERROR DETECTED during SubmatrixTrait class test:\n"
1242 << ex.what() << "\n";
1243 return EXIT_FAILURE;
1244 }
1245
1246 return EXIT_SUCCESS;
1247 }
1248 //*************************************************************************************************
1249