1 //=================================================================================================
2 /*!
3 //  \file src/mathtest/traits/krontrait/ClassTest.cpp
4 //  \brief Source file for the KronTrait 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/Aliases.h>
44 #include <blaze/math/CompressedMatrix.h>
45 #include <blaze/math/CompressedVector.h>
46 #include <blaze/math/CustomMatrix.h>
47 #include <blaze/math/CustomVector.h>
48 #include <blaze/math/DynamicMatrix.h>
49 #include <blaze/math/DynamicVector.h>
50 #include <blaze/math/HermitianMatrix.h>
51 #include <blaze/math/HybridMatrix.h>
52 #include <blaze/math/HybridVector.h>
53 #include <blaze/math/IdentityMatrix.h>
54 #include <blaze/math/InitializerMatrix.h>
55 #include <blaze/math/InitializerVector.h>
56 #include <blaze/math/LowerMatrix.h>
57 #include <blaze/math/StaticMatrix.h>
58 #include <blaze/math/StaticVector.h>
59 #include <blaze/math/StrictlyLowerMatrix.h>
60 #include <blaze/math/StrictlyUpperMatrix.h>
61 #include <blaze/math/SymmetricMatrix.h>
62 #include <blaze/math/traits/KronTrait.h>
63 #include <blaze/math/typetraits/StorageOrder.h>
64 #include <blaze/math/UniformMatrix.h>
65 #include <blaze/math/UniLowerMatrix.h>
66 #include <blaze/math/UniUpperMatrix.h>
67 #include <blaze/math/UpperMatrix.h>
68 #include <blaze/math/ZeroMatrix.h>
69 #include <blaze/math/ZeroVector.h>
70 #include <blaze/util/Complex.h>
71 #include <blaze/util/typetraits/IsSame.h>
72 #include <blaze/util/typetraits/RemoveCVRef.h>
73 #include <blazetest/mathtest/traits/krontrait/ClassTest.h>
74 
75 
76 namespace blazetest {
77 
78 namespace mathtest {
79 
80 namespace traits {
81 
82 namespace krontrait {
83 
84 //=================================================================================================
85 //
86 //  CONSTRUCTORS
87 //
88 //=================================================================================================
89 
90 //*************************************************************************************************
91 /*!\brief Constructor for the KronTrait class test.
92 //
93 // \exception std::runtime_error Error detected.
94 */
ClassTest()95 ClassTest::ClassTest()
96 {
97    testVectorKroneckerProduct();
98    testMatrixKroneckerProduct();
99 }
100 //*************************************************************************************************
101 
102 
103 
104 
105 //=================================================================================================
106 //
107 //  TEST FUNCTIONS
108 //
109 //=================================================================================================
110 
111 //*************************************************************************************************
112 /*!\brief Test of the 'KronTrait' class template for vector/vector Kronecker product operations.
113 //
114 // \return void
115 // \exception std::runtime_error Error detected.
116 //
117 // This function performs a compile time test of the 'KronTrait' class template for vector/vector
118 // Kronecker product operations. In case an error is detected, a compilation error is created.
119 */
testVectorKroneckerProduct()120 void ClassTest::testVectorKroneckerProduct()
121 {
122    using namespace blaze;
123 
124 
125    // StaticVector/...
126    {
127       // .../StaticVector
128       {
129          {
130             using T1 = StaticVector<int,3UL,columnVector>;
131             using T2 = StaticVector<double,2UL,columnVector>;
132             using RT = StaticVector<double,6UL,columnVector>;
133             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
134 
135             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
136             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
137             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
138          }
139          {
140             using T1 = StaticVector<int,3UL,rowVector>;
141             using T2 = StaticVector<double,2UL,rowVector>;
142             using RT = StaticVector<double,6UL,rowVector>;
143             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
144 
145             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
146             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
147             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
148          }
149       }
150 
151       // .../HybridVector
152       {
153          {
154             using T1 = StaticVector<int,3UL,columnVector>;
155             using T2 = HybridVector<double,2UL,columnVector>;
156             using RT = HybridVector<double,6UL,columnVector>;
157             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
158 
159             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
160             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
161             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
162          }
163          {
164             using T1 = StaticVector<int,3UL,rowVector>;
165             using T2 = HybridVector<double,2UL,rowVector>;
166             using RT = HybridVector<double,6UL,rowVector>;
167             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
168 
169             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
170             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
171             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
172          }
173       }
174 
175       // .../DynamicVector
176       {
177          {
178             using T1 = StaticVector<int,3UL,columnVector>;
179             using T2 = DynamicVector<double,columnVector>;
180             using RT = DynamicVector<double,columnVector>;
181             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
182 
183             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
184             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
185             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
186          }
187          {
188             using T1 = StaticVector<int,3UL,rowVector>;
189             using T2 = DynamicVector<double,rowVector>;
190             using RT = DynamicVector<double,rowVector>;
191             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
192 
193             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
194             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
195             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
196          }
197       }
198 
199       // .../CustomVector
200       {
201          {
202             using T1 = StaticVector<int,3UL,columnVector>;
203             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
204             using RT = DynamicVector<double,columnVector>;
205             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
206 
207             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
208             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
209             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
210          }
211          {
212             using T1 = StaticVector<int,3UL,rowVector>;
213             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
214             using RT = DynamicVector<double,rowVector>;
215             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
216 
217             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
218             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
219             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
220          }
221       }
222 
223       // .../UniformVector
224       {
225          {
226             using T1 = StaticVector<int,3UL,columnVector>;
227             using T2 = UniformVector<double,columnVector>;
228             using RT = DynamicVector<double,columnVector>;
229             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
230 
231             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
232             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
233             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
234          }
235          {
236             using T1 = StaticVector<int,3UL,rowVector>;
237             using T2 = UniformVector<double,rowVector>;
238             using RT = DynamicVector<double,rowVector>;
239             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
240 
241             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
242             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
243             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
244          }
245       }
246 
247       // .../InitializerVector
248       {
249          {
250             using T1 = StaticVector<int,3UL,columnVector>;
251             using T2 = InitializerVector<double,columnVector>;
252             using RT = DynamicVector<double,columnVector>;
253             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
254 
255             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
256             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
257             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
258          }
259          {
260             using T1 = StaticVector<int,3UL,rowVector>;
261             using T2 = InitializerVector<double,rowVector>;
262             using RT = DynamicVector<double,rowVector>;
263             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
264 
265             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
266             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
267             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
268          }
269       }
270 
271       // .../CompressedVector
272       {
273          {
274             using T1 = StaticVector<int,3UL,columnVector>;
275             using T2 = CompressedVector<double,columnVector>;
276             using RT = CompressedVector<double,columnVector>;
277             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
278 
279             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
280             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
281             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
282          }
283          {
284             using T1 = StaticVector<int,3UL,rowVector>;
285             using T2 = CompressedVector<double,rowVector>;
286             using RT = CompressedVector<double,rowVector>;
287             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
288 
289             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
290             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
291             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
292          }
293       }
294 
295       // .../ZeroVector
296       {
297          {
298             using T1 = StaticVector<int,3UL,columnVector>;
299             using T2 = ZeroVector<double,columnVector>;
300             using RT = ZeroVector<double,columnVector>;
301             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
302 
303             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
304             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
305             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
306          }
307          {
308             using T1 = StaticVector<int,3UL,rowVector>;
309             using T2 = ZeroVector<double,rowVector>;
310             using RT = ZeroVector<double,rowVector>;
311             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
312 
313             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
314             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
315             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
316          }
317       }
318    }
319 
320    // HybridVector/...
321    {
322       // .../StaticVector
323       {
324          {
325             using T1 = HybridVector<int,3UL,columnVector>;
326             using T2 = StaticVector<double,2UL,columnVector>;
327             using RT = HybridVector<double,6UL,columnVector>;
328             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
329 
330             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
331             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
332             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
333          }
334          {
335             using T1 = HybridVector<int,3UL,rowVector>;
336             using T2 = StaticVector<double,2UL,rowVector>;
337             using RT = HybridVector<double,6UL,rowVector>;
338             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
339 
340             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
341             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
342             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
343          }
344       }
345 
346       // .../HybridVector
347       {
348          {
349             using T1 = HybridVector<int,3UL,columnVector>;
350             using T2 = HybridVector<double,2UL,columnVector>;
351             using RT = HybridVector<double,6UL,columnVector>;
352             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
353 
354             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
355             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
356             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
357          }
358          {
359             using T1 = HybridVector<int,3UL,rowVector>;
360             using T2 = HybridVector<double,2UL,rowVector>;
361             using RT = HybridVector<double,6UL,rowVector>;
362             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
363 
364             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
365             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
366             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
367          }
368       }
369 
370       // .../DynamicVector
371       {
372          {
373             using T1 = HybridVector<int,3UL,columnVector>;
374             using T2 = DynamicVector<double,columnVector>;
375             using RT = DynamicVector<double,columnVector>;
376             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
377 
378             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
379             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
380             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
381          }
382          {
383             using T1 = HybridVector<int,3UL,rowVector>;
384             using T2 = DynamicVector<double,rowVector>;
385             using RT = DynamicVector<double,rowVector>;
386             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
387 
388             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
389             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
390             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
391          }
392       }
393 
394       // .../CustomVector
395       {
396          {
397             using T1 = HybridVector<int,3UL,columnVector>;
398             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
399             using RT = DynamicVector<double,columnVector>;
400             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
401 
402             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
403             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
404             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
405          }
406          {
407             using T1 = HybridVector<int,3UL,rowVector>;
408             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
409             using RT = DynamicVector<double,rowVector>;
410             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
411 
412             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
413             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
414             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
415          }
416       }
417 
418       // .../UniformVector
419       {
420          {
421             using T1 = HybridVector<int,3UL,columnVector>;
422             using T2 = UniformVector<double,columnVector>;
423             using RT = DynamicVector<double,columnVector>;
424             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
425 
426             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
427             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
428             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
429          }
430          {
431             using T1 = HybridVector<int,3UL,rowVector>;
432             using T2 = UniformVector<double,rowVector>;
433             using RT = DynamicVector<double,rowVector>;
434             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
435 
436             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
437             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
438             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
439          }
440       }
441 
442       // .../InitializerVector
443       {
444          {
445             using T1 = HybridVector<int,3UL,columnVector>;
446             using T2 = InitializerVector<double,columnVector>;
447             using RT = DynamicVector<double,columnVector>;
448             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
449 
450             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
451             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
452             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
453          }
454          {
455             using T1 = HybridVector<int,3UL,rowVector>;
456             using T2 = InitializerVector<double,rowVector>;
457             using RT = DynamicVector<double,rowVector>;
458             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
459 
460             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
461             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
462             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
463          }
464       }
465 
466       // .../CompressedVector
467       {
468          {
469             using T1 = HybridVector<int,3UL,columnVector>;
470             using T2 = CompressedVector<double,columnVector>;
471             using RT = CompressedVector<double,columnVector>;
472             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
473 
474             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
475             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
476             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
477          }
478          {
479             using T1 = HybridVector<int,3UL,rowVector>;
480             using T2 = CompressedVector<double,rowVector>;
481             using RT = CompressedVector<double,rowVector>;
482             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
483 
484             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
485             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
486             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
487          }
488       }
489 
490       // .../ZeroVector
491       {
492          {
493             using T1 = HybridVector<int,3UL,columnVector>;
494             using T2 = ZeroVector<double,columnVector>;
495             using RT = ZeroVector<double,columnVector>;
496             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
497 
498             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
499             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
500             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
501          }
502          {
503             using T1 = HybridVector<int,3UL,rowVector>;
504             using T2 = ZeroVector<double,rowVector>;
505             using RT = ZeroVector<double,rowVector>;
506             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
507 
508             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
509             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
510             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
511          }
512       }
513    }
514 
515    // DynamicVector/...
516    {
517       // .../StaticVector
518       {
519          {
520             using T1 = DynamicVector<int,columnVector>;
521             using T2 = StaticVector<double,2UL,columnVector>;
522             using RT = DynamicVector<double,columnVector>;
523             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
524 
525             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
526             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
527             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
528          }
529          {
530             using T1 = DynamicVector<int,rowVector>;
531             using T2 = StaticVector<double,2UL,rowVector>;
532             using RT = DynamicVector<double,rowVector>;
533             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
534 
535             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
536             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
537             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
538          }
539       }
540 
541       // .../HybridVector
542       {
543          {
544             using T1 = DynamicVector<int,columnVector>;
545             using T2 = HybridVector<double,2UL,columnVector>;
546             using RT = DynamicVector<double,columnVector>;
547             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
548 
549             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
550             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
551             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
552          }
553          {
554             using T1 = DynamicVector<int,rowVector>;
555             using T2 = HybridVector<double,2UL,rowVector>;
556             using RT = DynamicVector<double,rowVector>;
557             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
558 
559             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
560             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
561             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
562          }
563       }
564 
565       // .../DynamicVector
566       {
567          {
568             using T1 = DynamicVector<int,columnVector>;
569             using T2 = DynamicVector<double,columnVector>;
570             using RT = DynamicVector<double,columnVector>;
571             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
572 
573             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
574             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
575             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
576          }
577          {
578             using T1 = DynamicVector<int,rowVector>;
579             using T2 = DynamicVector<double,rowVector>;
580             using RT = DynamicVector<double,rowVector>;
581             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
582 
583             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
584             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
585             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
586          }
587       }
588 
589       // .../CustomVector
590       {
591          {
592             using T1 = DynamicVector<int,columnVector>;
593             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
594             using RT = DynamicVector<double,columnVector>;
595             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
596 
597             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
598             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
599             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
600          }
601          {
602             using T1 = DynamicVector<int,rowVector>;
603             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
604             using RT = DynamicVector<double,rowVector>;
605             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
606 
607             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
608             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
609             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
610          }
611       }
612 
613       // .../UniformVector
614       {
615          {
616             using T1 = DynamicVector<int,columnVector>;
617             using T2 = UniformVector<double,columnVector>;
618             using RT = DynamicVector<double,columnVector>;
619             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
620 
621             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
622             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
623             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
624          }
625          {
626             using T1 = DynamicVector<int,rowVector>;
627             using T2 = UniformVector<double,rowVector>;
628             using RT = DynamicVector<double,rowVector>;
629             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
630 
631             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
632             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
633             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
634          }
635       }
636 
637       // .../InitializerVector
638       {
639          {
640             using T1 = DynamicVector<int,columnVector>;
641             using T2 = InitializerVector<double,columnVector>;
642             using RT = DynamicVector<double,columnVector>;
643             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
644 
645             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
646             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
647             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
648          }
649          {
650             using T1 = DynamicVector<int,rowVector>;
651             using T2 = InitializerVector<double,rowVector>;
652             using RT = DynamicVector<double,rowVector>;
653             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
654 
655             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
656             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
657             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
658          }
659       }
660 
661       // .../CompressedVector
662       {
663          {
664             using T1 = DynamicVector<int,columnVector>;
665             using T2 = CompressedVector<double,columnVector>;
666             using RT = CompressedVector<double,columnVector>;
667             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
668 
669             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
670             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
671             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
672          }
673          {
674             using T1 = DynamicVector<int,rowVector>;
675             using T2 = CompressedVector<double,rowVector>;
676             using RT = CompressedVector<double,rowVector>;
677             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
678 
679             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
680             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
681             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
682          }
683       }
684 
685       // .../ZeroVector
686       {
687          {
688             using T1 = DynamicVector<int,columnVector>;
689             using T2 = ZeroVector<double,columnVector>;
690             using RT = ZeroVector<double,columnVector>;
691             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
692 
693             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
694             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
695             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
696          }
697          {
698             using T1 = DynamicVector<int,rowVector>;
699             using T2 = ZeroVector<double,rowVector>;
700             using RT = ZeroVector<double,rowVector>;
701             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
702 
703             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
704             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
705             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
706          }
707       }
708    }
709 
710    // CustomVector/...
711    {
712       // .../StaticVector
713       {
714          {
715             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
716             using T2 = StaticVector<double,2UL,columnVector>;
717             using RT = DynamicVector<double,columnVector>;
718             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
719 
720             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
721             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
722             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
723          }
724          {
725             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
726             using T2 = StaticVector<double,2UL,rowVector>;
727             using RT = DynamicVector<double,rowVector>;
728             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
729 
730             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
731             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
732             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
733          }
734       }
735 
736       // .../HybridVector
737       {
738          {
739             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
740             using T2 = HybridVector<double,2UL,columnVector>;
741             using RT = DynamicVector<double,columnVector>;
742             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
743 
744             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
745             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
746             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
747          }
748          {
749             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
750             using T2 = HybridVector<double,2UL,rowVector>;
751             using RT = DynamicVector<double,rowVector>;
752             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
753 
754             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
755             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
756             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
757          }
758       }
759 
760       // .../DynamicVector
761       {
762          {
763             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
764             using T2 = DynamicVector<double,columnVector>;
765             using RT = DynamicVector<double,columnVector>;
766             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
767 
768             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
769             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
770             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
771          }
772          {
773             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
774             using T2 = DynamicVector<double,rowVector>;
775             using RT = DynamicVector<double,rowVector>;
776             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
777 
778             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
779             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
780             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
781          }
782       }
783 
784       // .../CustomVector
785       {
786          {
787             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
788             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
789             using RT = DynamicVector<double,columnVector>;
790             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
791 
792             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
793             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
794             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
795          }
796          {
797             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
798             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
799             using RT = DynamicVector<double,rowVector>;
800             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
801 
802             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
803             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
804             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
805          }
806       }
807 
808       // .../UniformVector
809       {
810          {
811             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
812             using T2 = UniformVector<double,columnVector>;
813             using RT = DynamicVector<double,columnVector>;
814             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
815 
816             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
817             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
818             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
819          }
820          {
821             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
822             using T2 = UniformVector<double,rowVector>;
823             using RT = DynamicVector<double,rowVector>;
824             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
825 
826             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
827             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
828             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
829          }
830       }
831 
832       // .../InitializerVector
833       {
834          {
835             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
836             using T2 = InitializerVector<double,columnVector>;
837             using RT = DynamicVector<double,columnVector>;
838             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
839 
840             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
841             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
842             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
843          }
844          {
845             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
846             using T2 = InitializerVector<double,rowVector>;
847             using RT = DynamicVector<double,rowVector>;
848             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
849 
850             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
851             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
852             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
853          }
854       }
855 
856       // .../CompressedVector
857       {
858          {
859             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
860             using T2 = CompressedVector<double,columnVector>;
861             using RT = CompressedVector<double,columnVector>;
862             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
863 
864             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
865             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
866             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
867          }
868          {
869             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
870             using T2 = CompressedVector<double,rowVector>;
871             using RT = CompressedVector<double,rowVector>;
872             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
873 
874             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
875             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
876             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
877          }
878       }
879 
880       // .../ZeroVector
881       {
882          {
883             using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
884             using T2 = ZeroVector<double,columnVector>;
885             using RT = ZeroVector<double,columnVector>;
886             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
887 
888             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
889             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
890             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
891          }
892          {
893             using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
894             using T2 = ZeroVector<double,rowVector>;
895             using RT = ZeroVector<double,rowVector>;
896             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
897 
898             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
899             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
900             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
901          }
902       }
903    }
904 
905    // UniformVector/...
906    {
907       // .../StaticVector
908       {
909          {
910             using T1 = UniformVector<int,columnVector>;
911             using T2 = StaticVector<double,2UL,columnVector>;
912             using RT = DynamicVector<double,columnVector>;
913             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
914 
915             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
916             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
917             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
918          }
919          {
920             using T1 = UniformVector<int,rowVector>;
921             using T2 = StaticVector<double,2UL,rowVector>;
922             using RT = DynamicVector<double,rowVector>;
923             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
924 
925             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
926             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
927             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
928          }
929       }
930 
931       // .../HybridVector
932       {
933          {
934             using T1 = UniformVector<int,columnVector>;
935             using T2 = HybridVector<double,2UL,columnVector>;
936             using RT = DynamicVector<double,columnVector>;
937             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
938 
939             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
940             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
941             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
942          }
943          {
944             using T1 = UniformVector<int,rowVector>;
945             using T2 = HybridVector<double,2UL,rowVector>;
946             using RT = DynamicVector<double,rowVector>;
947             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
948 
949             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
950             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
951             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
952          }
953       }
954 
955       // .../DynamicVector
956       {
957          {
958             using T1 = UniformVector<int,columnVector>;
959             using T2 = DynamicVector<double,columnVector>;
960             using RT = DynamicVector<double,columnVector>;
961             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
962 
963             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
964             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
965             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
966          }
967          {
968             using T1 = UniformVector<int,rowVector>;
969             using T2 = DynamicVector<double,rowVector>;
970             using RT = DynamicVector<double,rowVector>;
971             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
972 
973             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
974             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
975             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
976          }
977       }
978 
979       // .../CustomVector
980       {
981          {
982             using T1 = UniformVector<int,columnVector>;
983             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
984             using RT = DynamicVector<double,columnVector>;
985             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
986 
987             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
988             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
989             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
990          }
991          {
992             using T1 = UniformVector<int,rowVector>;
993             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
994             using RT = DynamicVector<double,rowVector>;
995             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
996 
997             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
998             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
999             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1000          }
1001       }
1002 
1003       // .../UniformVector
1004       {
1005          {
1006             using T1 = UniformVector<int,columnVector>;
1007             using T2 = UniformVector<double,columnVector>;
1008             using RT = UniformVector<double,columnVector>;
1009             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1010 
1011             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1012             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1013             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1014          }
1015          {
1016             using T1 = UniformVector<int,rowVector>;
1017             using T2 = UniformVector<double,rowVector>;
1018             using RT = UniformVector<double,rowVector>;
1019             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1020 
1021             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1022             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1023             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1024          }
1025       }
1026 
1027       // .../InitializerVector
1028       {
1029          {
1030             using T1 = UniformVector<int,columnVector>;
1031             using T2 = InitializerVector<double,columnVector>;
1032             using RT = DynamicVector<double,columnVector>;
1033             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1034 
1035             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1036             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1037             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1038          }
1039          {
1040             using T1 = UniformVector<int,rowVector>;
1041             using T2 = InitializerVector<double,rowVector>;
1042             using RT = DynamicVector<double,rowVector>;
1043             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1044 
1045             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1046             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1047             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1048          }
1049       }
1050 
1051       // .../CompressedVector
1052       {
1053          {
1054             using T1 = UniformVector<int,columnVector>;
1055             using T2 = CompressedVector<double,columnVector>;
1056             using RT = CompressedVector<double,columnVector>;
1057             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1058 
1059             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1060             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1061             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1062          }
1063          {
1064             using T1 = UniformVector<int,rowVector>;
1065             using T2 = CompressedVector<double,rowVector>;
1066             using RT = CompressedVector<double,rowVector>;
1067             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1068 
1069             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1070             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1071             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1072          }
1073       }
1074 
1075       // .../ZeroVector
1076       {
1077          {
1078             using T1 = UniformVector<int,columnVector>;
1079             using T2 = ZeroVector<double,columnVector>;
1080             using RT = ZeroVector<double,columnVector>;
1081             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1082 
1083             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1084             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1085             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1086          }
1087          {
1088             using T1 = UniformVector<int,rowVector>;
1089             using T2 = ZeroVector<double,rowVector>;
1090             using RT = ZeroVector<double,rowVector>;
1091             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1092 
1093             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1094             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1095             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1096          }
1097       }
1098    }
1099 
1100    // InitializerVector/...
1101    {
1102       // .../StaticVector
1103       {
1104          {
1105             using T1 = InitializerVector<int,columnVector>;
1106             using T2 = StaticVector<double,2UL,columnVector>;
1107             using RT = DynamicVector<double,columnVector>;
1108             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1109 
1110             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1111             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1112             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1113          }
1114          {
1115             using T1 = InitializerVector<int,rowVector>;
1116             using T2 = StaticVector<double,2UL,rowVector>;
1117             using RT = DynamicVector<double,rowVector>;
1118             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1119 
1120             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1121             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1122             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1123          }
1124       }
1125 
1126       // .../HybridVector
1127       {
1128          {
1129             using T1 = InitializerVector<int,columnVector>;
1130             using T2 = HybridVector<double,2UL,columnVector>;
1131             using RT = DynamicVector<double,columnVector>;
1132             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1133 
1134             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1135             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1136             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1137          }
1138          {
1139             using T1 = InitializerVector<int,rowVector>;
1140             using T2 = HybridVector<double,2UL,rowVector>;
1141             using RT = DynamicVector<double,rowVector>;
1142             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1143 
1144             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1145             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1146             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1147          }
1148       }
1149 
1150       // .../DynamicVector
1151       {
1152          {
1153             using T1 = InitializerVector<int,columnVector>;
1154             using T2 = DynamicVector<double,columnVector>;
1155             using RT = DynamicVector<double,columnVector>;
1156             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1157 
1158             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1159             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1160             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1161          }
1162          {
1163             using T1 = InitializerVector<int,rowVector>;
1164             using T2 = DynamicVector<double,rowVector>;
1165             using RT = DynamicVector<double,rowVector>;
1166             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1167 
1168             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1169             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1170             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1171          }
1172       }
1173 
1174       // .../CustomVector
1175       {
1176          {
1177             using T1 = InitializerVector<int,columnVector>;
1178             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1179             using RT = DynamicVector<double,columnVector>;
1180             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1181 
1182             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1183             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1184             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1185          }
1186          {
1187             using T1 = InitializerVector<int,rowVector>;
1188             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1189             using RT = DynamicVector<double,rowVector>;
1190             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1191 
1192             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1193             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1194             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1195          }
1196       }
1197 
1198       // .../UniformVector
1199       {
1200          {
1201             using T1 = InitializerVector<int,columnVector>;
1202             using T2 = UniformVector<double,columnVector>;
1203             using RT = DynamicVector<double,columnVector>;
1204             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1205 
1206             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1207             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1208             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1209          }
1210          {
1211             using T1 = InitializerVector<int,rowVector>;
1212             using T2 = UniformVector<double,rowVector>;
1213             using RT = DynamicVector<double,rowVector>;
1214             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1215 
1216             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1217             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1218             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1219          }
1220       }
1221 
1222       // .../InitializerVector
1223       {
1224          {
1225             using T1 = InitializerVector<int,columnVector>;
1226             using T2 = InitializerVector<double,columnVector>;
1227             using RT = DynamicVector<double,columnVector>;
1228             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1229 
1230             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1231             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1232             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1233          }
1234          {
1235             using T1 = InitializerVector<int,rowVector>;
1236             using T2 = InitializerVector<double,rowVector>;
1237             using RT = DynamicVector<double,rowVector>;
1238             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1239 
1240             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1241             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1242             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1243          }
1244       }
1245 
1246       // .../CompressedVector
1247       {
1248          {
1249             using T1 = InitializerVector<int,columnVector>;
1250             using T2 = CompressedVector<double,columnVector>;
1251             using RT = CompressedVector<double,columnVector>;
1252             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1253 
1254             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1255             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1256             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1257          }
1258          {
1259             using T1 = InitializerVector<int,rowVector>;
1260             using T2 = CompressedVector<double,rowVector>;
1261             using RT = CompressedVector<double,rowVector>;
1262             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1263 
1264             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1265             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1266             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1267          }
1268       }
1269 
1270       // .../ZeroVector
1271       {
1272          {
1273             using T1 = InitializerVector<int,columnVector>;
1274             using T2 = ZeroVector<double,columnVector>;
1275             using RT = ZeroVector<double,columnVector>;
1276             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1277 
1278             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1279             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1280             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1281          }
1282          {
1283             using T1 = InitializerVector<int,rowVector>;
1284             using T2 = ZeroVector<double,rowVector>;
1285             using RT = ZeroVector<double,rowVector>;
1286             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1287 
1288             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1289             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1290             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1291          }
1292       }
1293    }
1294 
1295    // CompressedVector/...
1296    {
1297       // .../StaticVector
1298       {
1299          {
1300             using T1 = CompressedVector<int,columnVector>;
1301             using T2 = StaticVector<double,2UL,columnVector>;
1302             using RT = CompressedVector<double,columnVector>;
1303             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1304 
1305             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1306             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1307             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1308          }
1309          {
1310             using T1 = CompressedVector<int,rowVector>;
1311             using T2 = StaticVector<double,2UL,rowVector>;
1312             using RT = CompressedVector<double,rowVector>;
1313             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1314 
1315             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1316             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1317             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1318          }
1319       }
1320 
1321       // .../HybridVector
1322       {
1323          {
1324             using T1 = CompressedVector<int,columnVector>;
1325             using T2 = HybridVector<double,2UL,columnVector>;
1326             using RT = CompressedVector<double,columnVector>;
1327             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1328 
1329             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1330             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1331             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1332          }
1333          {
1334             using T1 = CompressedVector<int,rowVector>;
1335             using T2 = HybridVector<double,2UL,rowVector>;
1336             using RT = CompressedVector<double,rowVector>;
1337             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1338 
1339             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1340             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1341             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1342          }
1343       }
1344 
1345       // .../DynamicVector
1346       {
1347          {
1348             using T1 = CompressedVector<int,columnVector>;
1349             using T2 = DynamicVector<double,columnVector>;
1350             using RT = CompressedVector<double,columnVector>;
1351             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1352 
1353             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1354             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1355             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1356          }
1357          {
1358             using T1 = CompressedVector<int,rowVector>;
1359             using T2 = DynamicVector<double,rowVector>;
1360             using RT = CompressedVector<double,rowVector>;
1361             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1362 
1363             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1364             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1365             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1366          }
1367       }
1368 
1369       // .../CustomVector
1370       {
1371          {
1372             using T1 = CompressedVector<int,columnVector>;
1373             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1374             using RT = CompressedVector<double,columnVector>;
1375             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1376 
1377             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1378             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1379             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1380          }
1381          {
1382             using T1 = CompressedVector<int,rowVector>;
1383             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1384             using RT = CompressedVector<double,rowVector>;
1385             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1386 
1387             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1388             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1389             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1390          }
1391       }
1392 
1393       // .../UniformVector
1394       {
1395          {
1396             using T1 = CompressedVector<int,columnVector>;
1397             using T2 = UniformVector<double,columnVector>;
1398             using RT = CompressedVector<double,columnVector>;
1399             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1400 
1401             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1402             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1403             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1404          }
1405          {
1406             using T1 = CompressedVector<int,rowVector>;
1407             using T2 = UniformVector<double,rowVector>;
1408             using RT = CompressedVector<double,rowVector>;
1409             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1410 
1411             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1412             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1413             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1414          }
1415       }
1416 
1417       // .../InitializerVector
1418       {
1419          {
1420             using T1 = CompressedVector<int,columnVector>;
1421             using T2 = InitializerVector<double,columnVector>;
1422             using RT = CompressedVector<double,columnVector>;
1423             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1424 
1425             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1426             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1427             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1428          }
1429          {
1430             using T1 = CompressedVector<int,rowVector>;
1431             using T2 = InitializerVector<double,rowVector>;
1432             using RT = CompressedVector<double,rowVector>;
1433             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1434 
1435             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1436             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1437             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1438          }
1439       }
1440 
1441       // .../CompressedVector
1442       {
1443          {
1444             using T1 = CompressedVector<int,columnVector>;
1445             using T2 = CompressedVector<double,columnVector>;
1446             using RT = CompressedVector<double,columnVector>;
1447             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1448 
1449             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1450             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1451             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1452          }
1453          {
1454             using T1 = CompressedVector<int,rowVector>;
1455             using T2 = CompressedVector<double,rowVector>;
1456             using RT = CompressedVector<double,rowVector>;
1457             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1458 
1459             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1460             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1461             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1462          }
1463       }
1464 
1465       // .../ZeroVector
1466       {
1467          {
1468             using T1 = CompressedVector<int,columnVector>;
1469             using T2 = ZeroVector<double,columnVector>;
1470             using RT = ZeroVector<double,columnVector>;
1471             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1472 
1473             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1474             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1475             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1476          }
1477          {
1478             using T1 = CompressedVector<int,rowVector>;
1479             using T2 = ZeroVector<double,rowVector>;
1480             using RT = ZeroVector<double,rowVector>;
1481             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1482 
1483             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1484             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1485             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1486          }
1487       }
1488    }
1489 
1490    // ZeroVector/...
1491    {
1492       // .../StaticVector
1493       {
1494          {
1495             using T1 = ZeroVector<int,columnVector>;
1496             using T2 = StaticVector<double,2UL,columnVector>;
1497             using RT = ZeroVector<double,columnVector>;
1498             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1499 
1500             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1501             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1502             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1503          }
1504          {
1505             using T1 = ZeroVector<int,rowVector>;
1506             using T2 = StaticVector<double,2UL,rowVector>;
1507             using RT = ZeroVector<double,rowVector>;
1508             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1509 
1510             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1511             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1512             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1513          }
1514       }
1515 
1516       // .../HybridVector
1517       {
1518          {
1519             using T1 = ZeroVector<int,columnVector>;
1520             using T2 = HybridVector<double,2UL,columnVector>;
1521             using RT = ZeroVector<double,columnVector>;
1522             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1523 
1524             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1525             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1526             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1527          }
1528          {
1529             using T1 = ZeroVector<int,rowVector>;
1530             using T2 = HybridVector<double,2UL,rowVector>;
1531             using RT = ZeroVector<double,rowVector>;
1532             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1533 
1534             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1535             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1536             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1537          }
1538       }
1539 
1540       // .../DynamicVector
1541       {
1542          {
1543             using T1 = ZeroVector<int,columnVector>;
1544             using T2 = DynamicVector<double,columnVector>;
1545             using RT = ZeroVector<double,columnVector>;
1546             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1547 
1548             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1549             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1550             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1551          }
1552          {
1553             using T1 = ZeroVector<int,rowVector>;
1554             using T2 = DynamicVector<double,rowVector>;
1555             using RT = ZeroVector<double,rowVector>;
1556             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1557 
1558             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1559             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1560             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1561          }
1562       }
1563 
1564       // .../CustomVector
1565       {
1566          {
1567             using T1 = ZeroVector<int,columnVector>;
1568             using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1569             using RT = ZeroVector<double,columnVector>;
1570             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1571 
1572             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1573             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1574             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1575          }
1576          {
1577             using T1 = ZeroVector<int,rowVector>;
1578             using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1579             using RT = ZeroVector<double,rowVector>;
1580             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1581 
1582             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1583             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1584             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1585          }
1586       }
1587 
1588       // .../UniformVector
1589       {
1590          {
1591             using T1 = ZeroVector<int,columnVector>;
1592             using T2 = UniformVector<double,columnVector>;
1593             using RT = ZeroVector<double,columnVector>;
1594             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1595 
1596             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1597             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1598             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1599          }
1600          {
1601             using T1 = ZeroVector<int,rowVector>;
1602             using T2 = UniformVector<double,rowVector>;
1603             using RT = ZeroVector<double,rowVector>;
1604             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1605 
1606             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1607             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1608             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1609          }
1610       }
1611 
1612       // .../InitializerVector
1613       {
1614          {
1615             using T1 = ZeroVector<int,columnVector>;
1616             using T2 = InitializerVector<double,columnVector>;
1617             using RT = ZeroVector<double,columnVector>;
1618             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1619 
1620             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1621             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1622             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1623          }
1624          {
1625             using T1 = ZeroVector<int,rowVector>;
1626             using T2 = InitializerVector<double,rowVector>;
1627             using RT = ZeroVector<double,rowVector>;
1628             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1629 
1630             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1631             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1632             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1633          }
1634       }
1635 
1636       // .../CompressedVector
1637       {
1638          {
1639             using T1 = ZeroVector<int,columnVector>;
1640             using T2 = CompressedVector<double,columnVector>;
1641             using RT = ZeroVector<double,columnVector>;
1642             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1643 
1644             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1645             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1646             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1647          }
1648          {
1649             using T1 = ZeroVector<int,rowVector>;
1650             using T2 = CompressedVector<double,rowVector>;
1651             using RT = ZeroVector<double,rowVector>;
1652             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1653 
1654             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1655             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1656             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1657          }
1658       }
1659 
1660       // .../ZeroVector
1661       {
1662          {
1663             using T1 = ZeroVector<int,columnVector>;
1664             using T2 = ZeroVector<double,columnVector>;
1665             using RT = ZeroVector<double,columnVector>;
1666             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1667 
1668             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1669             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1670             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1671          }
1672          {
1673             using T1 = ZeroVector<int,rowVector>;
1674             using T2 = ZeroVector<double,rowVector>;
1675             using RT = ZeroVector<double,rowVector>;
1676             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1677 
1678             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1679             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1680             static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1681          }
1682       }
1683    }
1684 }
1685 //*************************************************************************************************
1686 
1687 
1688 //*************************************************************************************************
1689 /*!\brief Test of the 'KronTrait' class template for matrix/matrix Kronecker product operations.
1690 //
1691 // \return void
1692 // \exception std::runtime_error Error detected.
1693 //
1694 // This function performs a compile time test of the 'KronTrait' class template for matrix/matrix
1695 // Kronecker product operations. In case an error is detected, a compilation error is created.
1696 */
testMatrixKroneckerProduct()1697 void ClassTest::testMatrixKroneckerProduct()
1698 {
1699    using namespace blaze;
1700 
1701 
1702    // StaticMatrix/...
1703    {
1704       // .../StaticMatrix
1705       {
1706          {
1707             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1708             using T2 = StaticMatrix<double,2UL,3UL,rowMajor>;
1709             using RT = StaticMatrix<double,6UL,15UL,rowMajor>;
1710             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1711 
1712             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1713             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1714             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1715          }
1716          {
1717             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1718             using T2 = StaticMatrix<double,2UL,3UL,columnMajor>;
1719             using RT = StaticMatrix<double,6UL,15UL,columnMajor>;
1720             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1721 
1722             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1723             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1724             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1725          }
1726          {
1727             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1728             using T2 = StaticMatrix<double,2UL,3UL,rowMajor>;
1729             using RT = StaticMatrix<double,6UL,15UL,rowMajor>;
1730             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1731 
1732             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1733             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1734             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1735          }
1736          {
1737             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1738             using T2 = StaticMatrix<double,2UL,3UL,columnMajor>;
1739             using RT = StaticMatrix<double,6UL,15UL,columnMajor>;
1740             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1741 
1742             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1743             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1744             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1745          }
1746       }
1747 
1748       // .../HybridMatrix
1749       {
1750          {
1751             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1752             using T2 = HybridMatrix<double,2UL,3UL,rowMajor>;
1753             using RT = HybridMatrix<double,6UL,15UL,rowMajor>;
1754             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1755 
1756             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1757             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1758             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1759          }
1760          {
1761             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1762             using T2 = HybridMatrix<double,2UL,3UL,columnMajor>;
1763             using RT = HybridMatrix<double,6UL,15UL,columnMajor>;
1764             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1765 
1766             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1767             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1768             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1769          }
1770          {
1771             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1772             using T2 = HybridMatrix<double,2UL,3UL,rowMajor>;
1773             using RT = HybridMatrix<double,6UL,15UL,rowMajor>;
1774             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1775 
1776             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1777             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1778             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1779          }
1780          {
1781             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1782             using T2 = HybridMatrix<double,2UL,3UL,columnMajor>;
1783             using RT = HybridMatrix<double,6UL,15UL,columnMajor>;
1784             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1785 
1786             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1787             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1788             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1789          }
1790       }
1791 
1792       // .../DynamicMatrix
1793       {
1794          {
1795             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1796             using T2 = DynamicMatrix<double,rowMajor>;
1797             using RT = DynamicMatrix<double,rowMajor>;
1798             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1799 
1800             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1801             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1802             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1803          }
1804          {
1805             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1806             using T2 = DynamicMatrix<double,columnMajor>;
1807             using RT = DynamicMatrix<double,columnMajor>;
1808             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1809 
1810             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1811             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1812             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1813          }
1814          {
1815             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1816             using T2 = DynamicMatrix<double,rowMajor>;
1817             using RT = DynamicMatrix<double,rowMajor>;
1818             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1819 
1820             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1821             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1822             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1823          }
1824          {
1825             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1826             using T2 = DynamicMatrix<double,columnMajor>;
1827             using RT = DynamicMatrix<double,columnMajor>;
1828             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1829 
1830             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1831             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1832             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1833          }
1834       }
1835 
1836       // .../CustomMatrix
1837       {
1838          {
1839             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1840             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
1841             using RT = DynamicMatrix<double,rowMajor>;
1842             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1843 
1844             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1845             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1846             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1847          }
1848          {
1849             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1850             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
1851             using RT = DynamicMatrix<double,columnMajor>;
1852             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1853 
1854             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1855             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1856             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1857          }
1858          {
1859             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1860             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
1861             using RT = DynamicMatrix<double,rowMajor>;
1862             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1863 
1864             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1865             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1866             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1867          }
1868          {
1869             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1870             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
1871             using RT = DynamicMatrix<double,columnMajor>;
1872             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1873 
1874             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1875             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1876             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1877          }
1878       }
1879 
1880       // .../UniformMatrix
1881       {
1882          {
1883             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1884             using T2 = UniformMatrix<double,rowMajor>;
1885             using RT = DynamicMatrix<double,rowMajor>;
1886             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1887 
1888             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1889             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1890             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1891          }
1892          {
1893             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1894             using T2 = UniformMatrix<double,columnMajor>;
1895             using RT = DynamicMatrix<double,columnMajor>;
1896             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1897 
1898             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1899             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1900             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1901          }
1902          {
1903             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1904             using T2 = UniformMatrix<double,rowMajor>;
1905             using RT = DynamicMatrix<double,rowMajor>;
1906             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1907 
1908             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1909             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1910             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1911          }
1912          {
1913             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1914             using T2 = UniformMatrix<double,columnMajor>;
1915             using RT = DynamicMatrix<double,columnMajor>;
1916             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1917 
1918             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1919             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1920             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1921          }
1922       }
1923 
1924       // .../InitializerMatrix
1925       {
1926          {
1927             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1928             using T2 = InitializerMatrix<double>;
1929             using RT = DynamicMatrix<double,rowMajor>;
1930             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1931 
1932             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1933             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1934             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1935          }
1936          {
1937             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1938             using T2 = InitializerMatrix<double>;
1939             using RT = DynamicMatrix<double,rowMajor>;
1940             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1941 
1942             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1943             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1944             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1945          }
1946       }
1947 
1948       // .../CompressedMatrix
1949       {
1950          {
1951             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1952             using T2 = CompressedMatrix<double,rowMajor>;
1953             using RT = CompressedMatrix<double,rowMajor>;
1954             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1955 
1956             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1957             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1958             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1959          }
1960          {
1961             using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
1962             using T2 = CompressedMatrix<double,columnMajor>;
1963             using RT = CompressedMatrix<double,columnMajor>;
1964             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1965 
1966             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1967             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1968             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1969          }
1970          {
1971             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1972             using T2 = CompressedMatrix<double,rowMajor>;
1973             using RT = CompressedMatrix<double,rowMajor>;
1974             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1975 
1976             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1977             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1978             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1979          }
1980          {
1981             using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
1982             using T2 = CompressedMatrix<double,columnMajor>;
1983             using RT = CompressedMatrix<double,columnMajor>;
1984             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1985 
1986             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
1987             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
1988             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
1989          }
1990       }
1991 
1992       // .../IdentityMatrix
1993       {
1994          {
1995             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
1996             using T2 = IdentityMatrix<double,rowMajor>;
1997             using RT = CompressedMatrix<double,rowMajor>;
1998             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1999 
2000             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2001             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2002             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2003          }
2004          {
2005             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2006             using T2 = IdentityMatrix<double,columnMajor>;
2007             using RT = CompressedMatrix<double,columnMajor>;
2008             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2009 
2010             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2011             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2012             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2013          }
2014          {
2015             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2016             using T2 = IdentityMatrix<double,rowMajor>;
2017             using RT = CompressedMatrix<double,rowMajor>;
2018             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2019 
2020             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2021             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2022             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2023          }
2024          {
2025             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2026             using T2 = IdentityMatrix<double,columnMajor>;
2027             using RT = CompressedMatrix<double,columnMajor>;
2028             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2029 
2030             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2031             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2032             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2033          }
2034       }
2035 
2036       // .../ZeroMatrix
2037       {
2038          {
2039             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2040             using T2 = ZeroMatrix<double,rowMajor>;
2041             using RT = ZeroMatrix<double,rowMajor>;
2042             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2043 
2044             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2045             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2046             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2047          }
2048          {
2049             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2050             using T2 = ZeroMatrix<double,columnMajor>;
2051             using RT = ZeroMatrix<double,columnMajor>;
2052             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2053 
2054             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2055             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2056             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2057          }
2058          {
2059             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2060             using T2 = ZeroMatrix<double,rowMajor>;
2061             using RT = ZeroMatrix<double,rowMajor>;
2062             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2063 
2064             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2065             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2066             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2067          }
2068          {
2069             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2070             using T2 = ZeroMatrix<double,columnMajor>;
2071             using RT = ZeroMatrix<double,columnMajor>;
2072             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2073 
2074             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2075             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2076             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2077          }
2078       }
2079 
2080       // .../SymmetricMatrix<DynamicMatrix> (real)
2081       {
2082          {
2083             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2084             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
2085             using RT = DynamicMatrix<double,rowMajor>;
2086             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2087 
2088             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2089             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2090             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2091          }
2092          {
2093             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2094             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
2095             using RT = DynamicMatrix<double,columnMajor>;
2096             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2097 
2098             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2099             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2100             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2101          }
2102          {
2103             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2104             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
2105             using RT = DynamicMatrix<double,rowMajor>;
2106             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2107 
2108             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2109             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2110             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2111          }
2112          {
2113             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2114             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
2115             using RT = DynamicMatrix<double,columnMajor>;
2116             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2117 
2118             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2119             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2120             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2121          }
2122       }
2123 
2124       // .../SymmetricMatrix<DynamicMatrix> (complex)
2125       {
2126          {
2127             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2128             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
2129             using RT = DynamicMatrix<complex<int>,rowMajor>;
2130             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2131 
2132             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2133             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2134             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2135          }
2136          {
2137             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2138             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
2139             using RT = DynamicMatrix<complex<int>,columnMajor>;
2140             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2141 
2142             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2143             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2144             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2145          }
2146          {
2147             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2148             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
2149             using RT = DynamicMatrix<complex<int>,rowMajor>;
2150             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2151 
2152             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2153             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2154             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2155          }
2156          {
2157             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2158             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
2159             using RT = DynamicMatrix<complex<int>,columnMajor>;
2160             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2161 
2162             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2163             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2164             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2165          }
2166       }
2167 
2168       // .../SymmetricMatrix<UniformMatrix>
2169       {
2170          {
2171             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2172             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
2173             using RT = DynamicMatrix<double,rowMajor>;
2174             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2175 
2176             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2177             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2178             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2179          }
2180          {
2181             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2182             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
2183             using RT = DynamicMatrix<double,columnMajor>;
2184             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2185 
2186             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2187             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2188             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2189          }
2190          {
2191             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2192             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
2193             using RT = DynamicMatrix<double,rowMajor>;
2194             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2195 
2196             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2197             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2198             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2199          }
2200          {
2201             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2202             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
2203             using RT = DynamicMatrix<double,columnMajor>;
2204             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2205 
2206             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2207             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2208             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2209          }
2210       }
2211 
2212       // .../SymmetricMatrix<ZeroMatrix>
2213       {
2214          {
2215             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2216             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
2217             using RT = ZeroMatrix<double,rowMajor>;
2218             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2219 
2220             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2221             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2222             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2223          }
2224          {
2225             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2226             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
2227             using RT = ZeroMatrix<double,columnMajor>;
2228             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2229 
2230             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2231             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2232             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2233          }
2234          {
2235             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2236             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
2237             using RT = ZeroMatrix<double,rowMajor>;
2238             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2239 
2240             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2241             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2242             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2243          }
2244          {
2245             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2246             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
2247             using RT = ZeroMatrix<double,columnMajor>;
2248             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2249 
2250             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2251             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2252             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2253          }
2254       }
2255 
2256       // .../HermitianMatrix<DynamicMatrix> (symmetric)
2257       {
2258          {
2259             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2260             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
2261             using RT = DynamicMatrix<double,rowMajor>;
2262             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2263 
2264             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2265             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2266             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2267          }
2268          {
2269             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2270             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
2271             using RT = DynamicMatrix<double,columnMajor>;
2272             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2273 
2274             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2275             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2276             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2277          }
2278          {
2279             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2280             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
2281             using RT = DynamicMatrix<double,rowMajor>;
2282             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2283 
2284             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2285             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2286             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2287          }
2288          {
2289             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2290             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
2291             using RT = DynamicMatrix<double,columnMajor>;
2292             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2293 
2294             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2295             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2296             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2297          }
2298       }
2299 
2300       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
2301       {
2302          {
2303             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2304             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
2305             using RT = DynamicMatrix<complex<int>,rowMajor>;
2306             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2307 
2308             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2309             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2310             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2311          }
2312          {
2313             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2314             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
2315             using RT = DynamicMatrix<complex<int>,columnMajor>;
2316             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2317 
2318             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2319             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2320             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2321          }
2322          {
2323             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2324             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
2325             using RT = DynamicMatrix<complex<int>,rowMajor>;
2326             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2327 
2328             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2329             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2330             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2331          }
2332          {
2333             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2334             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
2335             using RT = DynamicMatrix<complex<int>,columnMajor>;
2336             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2337 
2338             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2339             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2340             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2341          }
2342       }
2343 
2344       // .../LowerMatrix<DynamicMatrix>
2345       {
2346          {
2347             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2348             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
2349             using RT = DynamicMatrix<double,rowMajor>;
2350             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2351 
2352             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2353             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2354             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2355          }
2356          {
2357             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2358             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
2359             using RT = DynamicMatrix<double,columnMajor>;
2360             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2361 
2362             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2363             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2364             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2365          }
2366          {
2367             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2368             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
2369             using RT = DynamicMatrix<double,rowMajor>;
2370             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2371 
2372             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2373             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2374             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2375          }
2376          {
2377             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2378             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
2379             using RT = DynamicMatrix<double,columnMajor>;
2380             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2381 
2382             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2383             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2384             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2385          }
2386       }
2387 
2388       // .../UniLowerMatrix<DynamicMatrix>
2389       {
2390          {
2391             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2392             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
2393             using RT = DynamicMatrix<double,rowMajor>;
2394             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2395 
2396             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2397             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2398             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2399          }
2400          {
2401             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2402             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
2403             using RT = DynamicMatrix<double,columnMajor>;
2404             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2405 
2406             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2407             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2408             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2409          }
2410          {
2411             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2412             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
2413             using RT = DynamicMatrix<double,rowMajor>;
2414             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2415 
2416             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2417             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2418             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2419          }
2420          {
2421             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2422             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
2423             using RT = DynamicMatrix<double,columnMajor>;
2424             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2425 
2426             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2427             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2428             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2429          }
2430       }
2431 
2432       // .../StrictlyLowerMatrix<DynamicMatrix>
2433       {
2434          {
2435             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2436             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
2437             using RT = DynamicMatrix<double,rowMajor>;
2438             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2439 
2440             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2441             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2442             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2443          }
2444          {
2445             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2446             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
2447             using RT = DynamicMatrix<double,columnMajor>;
2448             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2449 
2450             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2451             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2452             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2453          }
2454          {
2455             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2456             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
2457             using RT = DynamicMatrix<double,rowMajor>;
2458             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2459 
2460             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2461             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2462             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2463          }
2464          {
2465             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2466             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
2467             using RT = DynamicMatrix<double,columnMajor>;
2468             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2469 
2470             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2471             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2472             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2473          }
2474       }
2475 
2476       // .../UpperMatrix<DynamicMatrix>
2477       {
2478          {
2479             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2480             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
2481             using RT = DynamicMatrix<double,rowMajor>;
2482             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2483 
2484             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2485             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2486             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2487          }
2488          {
2489             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2490             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
2491             using RT = DynamicMatrix<double,columnMajor>;
2492             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2493 
2494             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2495             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2496             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2497          }
2498          {
2499             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2500             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
2501             using RT = DynamicMatrix<double,rowMajor>;
2502             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2503 
2504             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2505             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2506             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2507          }
2508          {
2509             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2510             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
2511             using RT = DynamicMatrix<double,columnMajor>;
2512             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2513 
2514             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2515             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2516             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2517          }
2518       }
2519 
2520       // .../UniUpperMatrix<DynamicMatrix>
2521       {
2522          {
2523             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2524             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
2525             using RT = DynamicMatrix<double,rowMajor>;
2526             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2527 
2528             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2529             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2530             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2531          }
2532          {
2533             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2534             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
2535             using RT = DynamicMatrix<double,columnMajor>;
2536             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2537 
2538             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2539             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2540             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2541          }
2542          {
2543             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2544             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
2545             using RT = DynamicMatrix<double,rowMajor>;
2546             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2547 
2548             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2549             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2550             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2551          }
2552          {
2553             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2554             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
2555             using RT = DynamicMatrix<double,columnMajor>;
2556             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2557 
2558             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2559             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2560             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2561          }
2562       }
2563 
2564       // .../StrictlyUpperMatrix<DynamicMatrix>
2565       {
2566          {
2567             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2568             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
2569             using RT = DynamicMatrix<double,rowMajor>;
2570             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2571 
2572             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2573             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2574             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2575          }
2576          {
2577             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2578             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
2579             using RT = DynamicMatrix<double,columnMajor>;
2580             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2581 
2582             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2583             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2584             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2585          }
2586          {
2587             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2588             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
2589             using RT = DynamicMatrix<double,rowMajor>;
2590             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2591 
2592             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2593             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2594             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2595          }
2596          {
2597             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2598             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
2599             using RT = DynamicMatrix<double,columnMajor>;
2600             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2601 
2602             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2603             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2604             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2605          }
2606       }
2607 
2608       // .../DiagonalMatrix<DynamicMatrix>
2609       {
2610          {
2611             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2612             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
2613             using RT = DynamicMatrix<double,rowMajor>;
2614             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2615 
2616             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2617             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2618             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2619          }
2620          {
2621             using T1 = StaticMatrix<int,3UL,3UL,rowMajor>;
2622             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
2623             using RT = DynamicMatrix<double,columnMajor>;
2624             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2625 
2626             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2627             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2628             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2629          }
2630          {
2631             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2632             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
2633             using RT = DynamicMatrix<double,rowMajor>;
2634             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2635 
2636             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2637             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2638             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2639          }
2640          {
2641             using T1 = StaticMatrix<int,3UL,3UL,columnMajor>;
2642             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
2643             using RT = DynamicMatrix<double,columnMajor>;
2644             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2645 
2646             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2647             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2648             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2649          }
2650       }
2651    }
2652 
2653    // HybridMatrix/...
2654    {
2655       // .../StaticMatrix
2656       {
2657          {
2658             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2659             using T2 = StaticMatrix<double,2UL,3UL,rowMajor>;
2660             using RT = HybridMatrix<double,10UL,21UL,rowMajor>;
2661             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2662 
2663             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2664             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2665             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2666          }
2667          {
2668             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2669             using T2 = StaticMatrix<double,2UL,3UL,columnMajor>;
2670             using RT = HybridMatrix<double,10UL,21UL,columnMajor>;
2671             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2672 
2673             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2674             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2675             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2676          }
2677          {
2678             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2679             using T2 = StaticMatrix<double,2UL,3UL,rowMajor>;
2680             using RT = HybridMatrix<double,10UL,21UL,rowMajor>;
2681             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2682 
2683             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2684             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2685             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2686          }
2687          {
2688             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2689             using T2 = StaticMatrix<double,2UL,3UL,columnMajor>;
2690             using RT = HybridMatrix<double,10UL,21UL,columnMajor>;
2691             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2692 
2693             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2694             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2695             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2696          }
2697       }
2698 
2699       // .../HybridMatrix
2700       {
2701          {
2702             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2703             using T2 = HybridMatrix<double,4UL,5UL,rowMajor>;
2704             using RT = HybridMatrix<double,20UL,35UL,rowMajor>;
2705             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2706 
2707             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2708             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2709             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2710          }
2711          {
2712             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2713             using T2 = HybridMatrix<double,4UL,5UL,columnMajor>;
2714             using RT = HybridMatrix<double,20UL,35UL,columnMajor>;
2715             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2716 
2717             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2718             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2719             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2720          }
2721          {
2722             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2723             using T2 = HybridMatrix<double,4UL,5UL,rowMajor>;
2724             using RT = HybridMatrix<double,20UL,35UL,rowMajor>;
2725             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2726 
2727             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2728             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2729             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2730          }
2731          {
2732             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2733             using T2 = HybridMatrix<double,4UL,5UL,columnMajor>;
2734             using RT = HybridMatrix<double,20UL,35UL,columnMajor>;
2735             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2736 
2737             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2738             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2739             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2740          }
2741       }
2742 
2743       // .../DynamicMatrix
2744       {
2745          {
2746             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2747             using T2 = DynamicMatrix<double,rowMajor>;
2748             using RT = DynamicMatrix<double,rowMajor>;
2749             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2750 
2751             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2752             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2753             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2754          }
2755          {
2756             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2757             using T2 = DynamicMatrix<double,columnMajor>;
2758             using RT = DynamicMatrix<double,columnMajor>;
2759             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2760 
2761             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2762             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2763             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2764          }
2765          {
2766             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2767             using T2 = DynamicMatrix<double,rowMajor>;
2768             using RT = DynamicMatrix<double,rowMajor>;
2769             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2770 
2771             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2772             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2773             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2774          }
2775          {
2776             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2777             using T2 = DynamicMatrix<double,columnMajor>;
2778             using RT = DynamicMatrix<double,columnMajor>;
2779             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2780 
2781             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2782             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2783             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2784          }
2785       }
2786 
2787       // .../CustomMatrix
2788       {
2789          {
2790             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2791             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
2792             using RT = DynamicMatrix<double,rowMajor>;
2793             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2794 
2795             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2796             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2797             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2798          }
2799          {
2800             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2801             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
2802             using RT = DynamicMatrix<double,columnMajor>;
2803             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2804 
2805             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2806             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2807             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2808          }
2809          {
2810             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2811             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
2812             using RT = DynamicMatrix<double,rowMajor>;
2813             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2814 
2815             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2816             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2817             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2818          }
2819          {
2820             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2821             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
2822             using RT = DynamicMatrix<double,columnMajor>;
2823             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2824 
2825             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2826             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2827             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2828          }
2829       }
2830 
2831       // .../UniformMatrix
2832       {
2833          {
2834             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2835             using T2 = UniformMatrix<double,rowMajor>;
2836             using RT = DynamicMatrix<double,rowMajor>;
2837             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2838 
2839             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2840             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2841             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2842          }
2843          {
2844             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2845             using T2 = UniformMatrix<double,columnMajor>;
2846             using RT = DynamicMatrix<double,columnMajor>;
2847             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2848 
2849             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2850             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2851             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2852          }
2853          {
2854             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2855             using T2 = UniformMatrix<double,rowMajor>;
2856             using RT = DynamicMatrix<double,rowMajor>;
2857             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2858 
2859             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2860             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2861             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2862          }
2863          {
2864             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2865             using T2 = UniformMatrix<double,columnMajor>;
2866             using RT = DynamicMatrix<double,columnMajor>;
2867             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2868 
2869             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2870             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2871             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2872          }
2873       }
2874 
2875       // .../InitializerMatrix
2876       {
2877          {
2878             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2879             using T2 = InitializerMatrix<double>;
2880             using RT = DynamicMatrix<double,rowMajor>;
2881             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2882 
2883             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2884             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2885             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2886          }
2887          {
2888             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2889             using T2 = InitializerMatrix<double>;
2890             using RT = DynamicMatrix<double,rowMajor>;
2891             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2892 
2893             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2894             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2895             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2896          }
2897       }
2898 
2899       // .../CompressedMatrix
2900       {
2901          {
2902             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2903             using T2 = CompressedMatrix<double,rowMajor>;
2904             using RT = CompressedMatrix<double,rowMajor>;
2905             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2906 
2907             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2908             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2909             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2910          }
2911          {
2912             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2913             using T2 = CompressedMatrix<double,columnMajor>;
2914             using RT = CompressedMatrix<double,columnMajor>;
2915             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2916 
2917             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2918             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2919             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2920          }
2921          {
2922             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2923             using T2 = CompressedMatrix<double,rowMajor>;
2924             using RT = CompressedMatrix<double,rowMajor>;
2925             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2926 
2927             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2928             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2929             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2930          }
2931          {
2932             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2933             using T2 = CompressedMatrix<double,columnMajor>;
2934             using RT = CompressedMatrix<double,columnMajor>;
2935             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2936 
2937             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2938             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2939             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2940          }
2941       }
2942 
2943       // .../IdentityMatrix
2944       {
2945          {
2946             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2947             using T2 = IdentityMatrix<double,rowMajor>;
2948             using RT = CompressedMatrix<double,rowMajor>;
2949             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2950 
2951             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2952             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2953             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2954          }
2955          {
2956             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2957             using T2 = IdentityMatrix<double,columnMajor>;
2958             using RT = CompressedMatrix<double,columnMajor>;
2959             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2960 
2961             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2962             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2963             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2964          }
2965          {
2966             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2967             using T2 = IdentityMatrix<double,rowMajor>;
2968             using RT = CompressedMatrix<double,rowMajor>;
2969             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2970 
2971             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2972             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2973             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2974          }
2975          {
2976             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
2977             using T2 = IdentityMatrix<double,columnMajor>;
2978             using RT = CompressedMatrix<double,columnMajor>;
2979             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2980 
2981             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2982             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2983             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2984          }
2985       }
2986 
2987       // .../ZeroMatrix
2988       {
2989          {
2990             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
2991             using T2 = ZeroMatrix<double,rowMajor>;
2992             using RT = ZeroMatrix<double,rowMajor>;
2993             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2994 
2995             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
2996             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
2997             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
2998          }
2999          {
3000             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3001             using T2 = ZeroMatrix<double,columnMajor>;
3002             using RT = ZeroMatrix<double,columnMajor>;
3003             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3004 
3005             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3006             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3007             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3008          }
3009          {
3010             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3011             using T2 = ZeroMatrix<double,rowMajor>;
3012             using RT = ZeroMatrix<double,rowMajor>;
3013             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3014 
3015             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3016             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3017             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3018          }
3019          {
3020             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3021             using T2 = ZeroMatrix<double,columnMajor>;
3022             using RT = ZeroMatrix<double,columnMajor>;
3023             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3024 
3025             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3026             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3027             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3028          }
3029       }
3030 
3031       // .../SymmetricMatrix<DynamicMatrix> (real)
3032       {
3033          {
3034             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3035             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
3036             using RT = DynamicMatrix<double,rowMajor>;
3037             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3038 
3039             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3040             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3041             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3042          }
3043          {
3044             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3045             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
3046             using RT = DynamicMatrix<double,columnMajor>;
3047             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3048 
3049             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3050             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3051             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3052          }
3053          {
3054             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3055             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
3056             using RT = DynamicMatrix<double,rowMajor>;
3057             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3058 
3059             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3060             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3061             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3062          }
3063          {
3064             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3065             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
3066             using RT = DynamicMatrix<double,columnMajor>;
3067             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3068 
3069             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3070             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3071             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3072          }
3073       }
3074 
3075       // .../SymmetricMatrix<DynamicMatrix> (complex)
3076       {
3077          {
3078             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3079             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
3080             using RT = DynamicMatrix<complex<int>,rowMajor>;
3081             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3082 
3083             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3084             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3085             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3086          }
3087          {
3088             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3089             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
3090             using RT = DynamicMatrix<complex<int>,columnMajor>;
3091             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3092 
3093             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3094             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3095             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3096          }
3097          {
3098             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3099             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
3100             using RT = DynamicMatrix<complex<int>,rowMajor>;
3101             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3102 
3103             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3104             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3105             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3106          }
3107          {
3108             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3109             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
3110             using RT = DynamicMatrix<complex<int>,columnMajor>;
3111             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3112 
3113             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3114             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3115             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3116          }
3117       }
3118 
3119       // .../SymmetricMatrix<UniformMatrix>
3120       {
3121          {
3122             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3123             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
3124             using RT = DynamicMatrix<double,rowMajor>;
3125             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3126 
3127             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3128             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3129             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3130          }
3131          {
3132             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3133             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
3134             using RT = DynamicMatrix<double,columnMajor>;
3135             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3136 
3137             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3138             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3139             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3140          }
3141          {
3142             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3143             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
3144             using RT = DynamicMatrix<double,rowMajor>;
3145             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3146 
3147             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3148             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3149             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3150          }
3151          {
3152             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3153             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
3154             using RT = DynamicMatrix<double,columnMajor>;
3155             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3156 
3157             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3158             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3159             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3160          }
3161       }
3162 
3163       // .../SymmetricMatrix<ZeroMatrix>
3164       {
3165          {
3166             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3167             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
3168             using RT = ZeroMatrix<double,rowMajor>;
3169             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3170 
3171             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3172             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3173             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3174          }
3175          {
3176             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3177             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
3178             using RT = ZeroMatrix<double,columnMajor>;
3179             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3180 
3181             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3182             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3183             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3184          }
3185          {
3186             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3187             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
3188             using RT = ZeroMatrix<double,rowMajor>;
3189             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3190 
3191             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3192             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3193             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3194          }
3195          {
3196             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3197             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
3198             using RT = ZeroMatrix<double,columnMajor>;
3199             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3200 
3201             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3202             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3203             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3204          }
3205       }
3206 
3207       // .../HermitianMatrix<DynamicMatrix> (symmetric)
3208       {
3209          {
3210             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3211             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
3212             using RT = DynamicMatrix<double,rowMajor>;
3213             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3214 
3215             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3216             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3217             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3218          }
3219          {
3220             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3221             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
3222             using RT = DynamicMatrix<double,columnMajor>;
3223             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3224 
3225             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3226             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3227             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3228          }
3229          {
3230             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3231             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
3232             using RT = DynamicMatrix<double,rowMajor>;
3233             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3234 
3235             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3236             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3237             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3238          }
3239          {
3240             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3241             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
3242             using RT = DynamicMatrix<double,columnMajor>;
3243             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3244 
3245             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3246             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3247             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3248          }
3249       }
3250 
3251       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
3252       {
3253          {
3254             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3255             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
3256             using RT = DynamicMatrix<complex<int>,rowMajor>;
3257             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3258 
3259             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3260             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3261             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3262          }
3263          {
3264             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3265             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
3266             using RT = DynamicMatrix<complex<int>,columnMajor>;
3267             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3268 
3269             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3270             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3271             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3272          }
3273          {
3274             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3275             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
3276             using RT = DynamicMatrix<complex<int>,rowMajor>;
3277             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3278 
3279             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3280             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3281             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3282          }
3283          {
3284             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3285             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
3286             using RT = DynamicMatrix<complex<int>,columnMajor>;
3287             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3288 
3289             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3290             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3291             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3292          }
3293       }
3294 
3295       // .../LowerMatrix<DynamicMatrix>
3296       {
3297          {
3298             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3299             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
3300             using RT = DynamicMatrix<double,rowMajor>;
3301             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3302 
3303             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3304             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3305             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3306          }
3307          {
3308             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3309             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
3310             using RT = DynamicMatrix<double,columnMajor>;
3311             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3312 
3313             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3314             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3315             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3316          }
3317          {
3318             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3319             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
3320             using RT = DynamicMatrix<double,rowMajor>;
3321             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3322 
3323             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3324             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3325             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3326          }
3327          {
3328             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3329             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
3330             using RT = DynamicMatrix<double,columnMajor>;
3331             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3332 
3333             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3334             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3335             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3336          }
3337       }
3338 
3339       // .../UniLowerMatrix<DynamicMatrix>
3340       {
3341          {
3342             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3343             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
3344             using RT = DynamicMatrix<double,rowMajor>;
3345             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3346 
3347             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3348             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3349             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3350          }
3351          {
3352             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3353             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
3354             using RT = DynamicMatrix<double,columnMajor>;
3355             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3356 
3357             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3358             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3359             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3360          }
3361          {
3362             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3363             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
3364             using RT = DynamicMatrix<double,rowMajor>;
3365             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3366 
3367             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3368             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3369             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3370          }
3371          {
3372             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3373             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
3374             using RT = DynamicMatrix<double,columnMajor>;
3375             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3376 
3377             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3378             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3379             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3380          }
3381       }
3382 
3383       // .../StrictlyLowerMatrix<DynamicMatrix>
3384       {
3385          {
3386             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3387             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
3388             using RT = DynamicMatrix<double,rowMajor>;
3389             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3390 
3391             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3392             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3393             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3394          }
3395          {
3396             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3397             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
3398             using RT = DynamicMatrix<double,columnMajor>;
3399             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3400 
3401             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3402             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3403             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3404          }
3405          {
3406             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3407             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
3408             using RT = DynamicMatrix<double,rowMajor>;
3409             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3410 
3411             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3412             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3413             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3414          }
3415          {
3416             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3417             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
3418             using RT = DynamicMatrix<double,columnMajor>;
3419             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3420 
3421             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3422             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3423             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3424          }
3425       }
3426 
3427       // .../UpperMatrix<DynamicMatrix>
3428       {
3429          {
3430             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3431             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
3432             using RT = DynamicMatrix<double,rowMajor>;
3433             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3434 
3435             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3436             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3437             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3438          }
3439          {
3440             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3441             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
3442             using RT = DynamicMatrix<double,columnMajor>;
3443             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3444 
3445             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3446             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3447             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3448          }
3449          {
3450             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3451             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
3452             using RT = DynamicMatrix<double,rowMajor>;
3453             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3454 
3455             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3456             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3457             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3458          }
3459          {
3460             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3461             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
3462             using RT = DynamicMatrix<double,columnMajor>;
3463             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3464 
3465             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3466             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3467             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3468          }
3469       }
3470 
3471       // .../UniUpperMatrix<DynamicMatrix>
3472       {
3473          {
3474             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3475             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
3476             using RT = DynamicMatrix<double,rowMajor>;
3477             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3478 
3479             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3480             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3481             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3482          }
3483          {
3484             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3485             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
3486             using RT = DynamicMatrix<double,columnMajor>;
3487             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3488 
3489             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3490             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3491             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3492          }
3493          {
3494             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3495             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
3496             using RT = DynamicMatrix<double,rowMajor>;
3497             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3498 
3499             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3500             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3501             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3502          }
3503          {
3504             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3505             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
3506             using RT = DynamicMatrix<double,columnMajor>;
3507             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3508 
3509             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3510             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3511             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3512          }
3513       }
3514 
3515       // .../StrictlyUpperMatrix<DynamicMatrix>
3516       {
3517          {
3518             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3519             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
3520             using RT = DynamicMatrix<double,rowMajor>;
3521             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3522 
3523             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3524             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3525             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3526          }
3527          {
3528             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3529             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
3530             using RT = DynamicMatrix<double,columnMajor>;
3531             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3532 
3533             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3534             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3535             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3536          }
3537          {
3538             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3539             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
3540             using RT = DynamicMatrix<double,rowMajor>;
3541             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3542 
3543             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3544             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3545             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3546          }
3547          {
3548             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3549             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
3550             using RT = DynamicMatrix<double,columnMajor>;
3551             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3552 
3553             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3554             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3555             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3556          }
3557       }
3558 
3559       // .../DiagonalMatrix<DynamicMatrix>
3560       {
3561          {
3562             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3563             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
3564             using RT = DynamicMatrix<double,rowMajor>;
3565             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3566 
3567             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3568             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3569             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3570          }
3571          {
3572             using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
3573             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
3574             using RT = DynamicMatrix<double,columnMajor>;
3575             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3576 
3577             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3578             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3579             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3580          }
3581          {
3582             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3583             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
3584             using RT = DynamicMatrix<double,rowMajor>;
3585             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3586 
3587             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3588             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3589             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3590          }
3591          {
3592             using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
3593             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
3594             using RT = DynamicMatrix<double,columnMajor>;
3595             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3596 
3597             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3598             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3599             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3600          }
3601       }
3602    }
3603 
3604    // DynamicMatrix/...
3605    {
3606       // .../StaticMatrix
3607       {
3608          {
3609             using T1 = DynamicMatrix<int,rowMajor>;
3610             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
3611             using RT = DynamicMatrix<double,rowMajor>;
3612             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3613 
3614             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3615             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3616             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3617          }
3618          {
3619             using T1 = DynamicMatrix<int,rowMajor>;
3620             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
3621             using RT = DynamicMatrix<double,columnMajor>;
3622             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3623 
3624             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3625             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3626             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3627          }
3628          {
3629             using T1 = DynamicMatrix<int,columnMajor>;
3630             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
3631             using RT = DynamicMatrix<double,rowMajor>;
3632             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3633 
3634             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3635             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3636             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3637          }
3638          {
3639             using T1 = DynamicMatrix<int,columnMajor>;
3640             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
3641             using RT = DynamicMatrix<double,columnMajor>;
3642             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3643 
3644             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3645             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3646             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3647          }
3648       }
3649 
3650       // .../HybridMatrix
3651       {
3652          {
3653             using T1 = DynamicMatrix<int,rowMajor>;
3654             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
3655             using RT = DynamicMatrix<double,rowMajor>;
3656             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3657 
3658             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3659             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3660             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3661          }
3662          {
3663             using T1 = DynamicMatrix<int,rowMajor>;
3664             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
3665             using RT = DynamicMatrix<double,columnMajor>;
3666             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3667 
3668             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3669             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3670             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3671          }
3672          {
3673             using T1 = DynamicMatrix<int,columnMajor>;
3674             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
3675             using RT = DynamicMatrix<double,rowMajor>;
3676             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3677 
3678             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3679             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3680             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3681          }
3682          {
3683             using T1 = DynamicMatrix<int,columnMajor>;
3684             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
3685             using RT = DynamicMatrix<double,columnMajor>;
3686             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3687 
3688             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3689             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3690             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3691          }
3692       }
3693 
3694       // .../DynamicMatrix
3695       {
3696          {
3697             using T1 = DynamicMatrix<int,rowMajor>;
3698             using T2 = DynamicMatrix<double,rowMajor>;
3699             using RT = DynamicMatrix<double,rowMajor>;
3700             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3701 
3702             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3703             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3704             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3705          }
3706          {
3707             using T1 = DynamicMatrix<int,rowMajor>;
3708             using T2 = DynamicMatrix<double,columnMajor>;
3709             using RT = DynamicMatrix<double,columnMajor>;
3710             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3711 
3712             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3713             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3714             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3715          }
3716          {
3717             using T1 = DynamicMatrix<int,columnMajor>;
3718             using T2 = DynamicMatrix<double,rowMajor>;
3719             using RT = DynamicMatrix<double,rowMajor>;
3720             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3721 
3722             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3723             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3724             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3725          }
3726          {
3727             using T1 = DynamicMatrix<int,columnMajor>;
3728             using T2 = DynamicMatrix<double,columnMajor>;
3729             using RT = DynamicMatrix<double,columnMajor>;
3730             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3731 
3732             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3733             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3734             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3735          }
3736       }
3737 
3738       // .../CustomMatrix
3739       {
3740          {
3741             using T1 = DynamicMatrix<int,rowMajor>;
3742             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
3743             using RT = DynamicMatrix<double,rowMajor>;
3744             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3745 
3746             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3747             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3748             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3749          }
3750          {
3751             using T1 = DynamicMatrix<int,rowMajor>;
3752             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
3753             using RT = DynamicMatrix<double,columnMajor>;
3754             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3755 
3756             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3757             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3758             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3759          }
3760          {
3761             using T1 = DynamicMatrix<int,columnMajor>;
3762             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
3763             using RT = DynamicMatrix<double,rowMajor>;
3764             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3765 
3766             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3767             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3768             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3769          }
3770          {
3771             using T1 = DynamicMatrix<int,columnMajor>;
3772             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
3773             using RT = DynamicMatrix<double,columnMajor>;
3774             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3775 
3776             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3777             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3778             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3779          }
3780       }
3781 
3782       // .../UniformMatrix
3783       {
3784          {
3785             using T1 = DynamicMatrix<int,rowMajor>;
3786             using T2 = UniformMatrix<double,rowMajor>;
3787             using RT = DynamicMatrix<double,rowMajor>;
3788             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3789 
3790             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3791             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3792             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3793          }
3794          {
3795             using T1 = DynamicMatrix<int,rowMajor>;
3796             using T2 = UniformMatrix<double,columnMajor>;
3797             using RT = DynamicMatrix<double,columnMajor>;
3798             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3799 
3800             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3801             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3802             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3803          }
3804          {
3805             using T1 = DynamicMatrix<int,columnMajor>;
3806             using T2 = UniformMatrix<double,rowMajor>;
3807             using RT = DynamicMatrix<double,rowMajor>;
3808             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3809 
3810             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3811             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3812             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3813          }
3814          {
3815             using T1 = DynamicMatrix<int,columnMajor>;
3816             using T2 = UniformMatrix<double,columnMajor>;
3817             using RT = DynamicMatrix<double,columnMajor>;
3818             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3819 
3820             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3821             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3822             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3823          }
3824       }
3825 
3826       // .../InitializerMatrix
3827       {
3828          {
3829             using T1 = DynamicMatrix<int,rowMajor>;
3830             using T2 = InitializerMatrix<double>;
3831             using RT = DynamicMatrix<double,rowMajor>;
3832             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3833 
3834             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3835             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3836             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3837          }
3838          {
3839             using T1 = DynamicMatrix<int,columnMajor>;
3840             using T2 = InitializerMatrix<double>;
3841             using RT = DynamicMatrix<double,rowMajor>;
3842             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3843 
3844             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3845             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3846             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3847          }
3848       }
3849 
3850       // .../CompressedMatrix
3851       {
3852          {
3853             using T1 = DynamicMatrix<int,rowMajor>;
3854             using T2 = CompressedMatrix<double,rowMajor>;
3855             using RT = CompressedMatrix<double,rowMajor>;
3856             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3857 
3858             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3859             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3860             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3861          }
3862          {
3863             using T1 = DynamicMatrix<int,rowMajor>;
3864             using T2 = CompressedMatrix<double,columnMajor>;
3865             using RT = CompressedMatrix<double,columnMajor>;
3866             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3867 
3868             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3869             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3870             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3871          }
3872          {
3873             using T1 = DynamicMatrix<int,columnMajor>;
3874             using T2 = CompressedMatrix<double,rowMajor>;
3875             using RT = CompressedMatrix<double,rowMajor>;
3876             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3877 
3878             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3879             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3880             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3881          }
3882          {
3883             using T1 = DynamicMatrix<int,columnMajor>;
3884             using T2 = CompressedMatrix<double,columnMajor>;
3885             using RT = CompressedMatrix<double,columnMajor>;
3886             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3887 
3888             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3889             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3890             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3891          }
3892       }
3893 
3894       // .../IdentityMatrix
3895       {
3896          {
3897             using T1 = DynamicMatrix<int,rowMajor>;
3898             using T2 = IdentityMatrix<double,rowMajor>;
3899             using RT = CompressedMatrix<double,rowMajor>;
3900             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3901 
3902             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3903             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3904             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3905          }
3906          {
3907             using T1 = DynamicMatrix<int,rowMajor>;
3908             using T2 = IdentityMatrix<double,columnMajor>;
3909             using RT = CompressedMatrix<double,columnMajor>;
3910             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3911 
3912             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3913             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3914             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3915          }
3916          {
3917             using T1 = DynamicMatrix<int,columnMajor>;
3918             using T2 = IdentityMatrix<double,rowMajor>;
3919             using RT = CompressedMatrix<double,rowMajor>;
3920             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3921 
3922             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3923             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3924             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3925          }
3926          {
3927             using T1 = DynamicMatrix<int,columnMajor>;
3928             using T2 = IdentityMatrix<double,columnMajor>;
3929             using RT = CompressedMatrix<double,columnMajor>;
3930             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3931 
3932             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3933             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3934             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3935          }
3936       }
3937 
3938       // .../ZeroMatrix
3939       {
3940          {
3941             using T1 = DynamicMatrix<int,rowMajor>;
3942             using T2 = ZeroMatrix<double,rowMajor>;
3943             using RT = ZeroMatrix<double,rowMajor>;
3944             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3945 
3946             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3947             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3948             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3949          }
3950          {
3951             using T1 = DynamicMatrix<int,rowMajor>;
3952             using T2 = ZeroMatrix<double,columnMajor>;
3953             using RT = ZeroMatrix<double,columnMajor>;
3954             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3955 
3956             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3957             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3958             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3959          }
3960          {
3961             using T1 = DynamicMatrix<int,columnMajor>;
3962             using T2 = ZeroMatrix<double,rowMajor>;
3963             using RT = ZeroMatrix<double,rowMajor>;
3964             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3965 
3966             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3967             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3968             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3969          }
3970          {
3971             using T1 = DynamicMatrix<int,columnMajor>;
3972             using T2 = ZeroMatrix<double,columnMajor>;
3973             using RT = ZeroMatrix<double,columnMajor>;
3974             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3975 
3976             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3977             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3978             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3979          }
3980       }
3981 
3982       // .../SymmetricMatrix<DynamicMatrix> (real)
3983       {
3984          {
3985             using T1 = DynamicMatrix<int,rowMajor>;
3986             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
3987             using RT = DynamicMatrix<double,rowMajor>;
3988             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3989 
3990             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
3991             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
3992             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
3993          }
3994          {
3995             using T1 = DynamicMatrix<int,rowMajor>;
3996             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
3997             using RT = DynamicMatrix<double,columnMajor>;
3998             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
3999 
4000             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4001             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4002             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4003          }
4004          {
4005             using T1 = DynamicMatrix<int,columnMajor>;
4006             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
4007             using RT = DynamicMatrix<double,rowMajor>;
4008             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4009 
4010             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4011             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4012             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4013          }
4014          {
4015             using T1 = DynamicMatrix<int,columnMajor>;
4016             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
4017             using RT = DynamicMatrix<double,columnMajor>;
4018             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4019 
4020             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4021             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4022             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4023          }
4024       }
4025 
4026       // .../SymmetricMatrix<DynamicMatrix> (complex)
4027       {
4028          {
4029             using T1 = DynamicMatrix<int,rowMajor>;
4030             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
4031             using RT = DynamicMatrix<complex<int>,rowMajor>;
4032             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4033 
4034             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4035             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4036             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4037          }
4038          {
4039             using T1 = DynamicMatrix<int,rowMajor>;
4040             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
4041             using RT = DynamicMatrix<complex<int>,columnMajor>;
4042             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4043 
4044             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4045             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4046             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4047          }
4048          {
4049             using T1 = DynamicMatrix<int,columnMajor>;
4050             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
4051             using RT = DynamicMatrix<complex<int>,rowMajor>;
4052             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4053 
4054             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4055             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4056             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4057          }
4058          {
4059             using T1 = DynamicMatrix<int,columnMajor>;
4060             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
4061             using RT = DynamicMatrix<complex<int>,columnMajor>;
4062             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4063 
4064             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4065             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4066             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4067          }
4068       }
4069 
4070       // .../SymmetricMatrix<UniformMatrix>
4071       {
4072          {
4073             using T1 = DynamicMatrix<int,rowMajor>;
4074             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
4075             using RT = DynamicMatrix<double,rowMajor>;
4076             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4077 
4078             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4079             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4080             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4081          }
4082          {
4083             using T1 = DynamicMatrix<int,rowMajor>;
4084             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
4085             using RT = DynamicMatrix<double,columnMajor>;
4086             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4087 
4088             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4089             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4090             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4091          }
4092          {
4093             using T1 = DynamicMatrix<int,columnMajor>;
4094             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
4095             using RT = DynamicMatrix<double,rowMajor>;
4096             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4097 
4098             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4099             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4100             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4101          }
4102          {
4103             using T1 = DynamicMatrix<int,columnMajor>;
4104             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
4105             using RT = DynamicMatrix<double,columnMajor>;
4106             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4107 
4108             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4109             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4110             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4111          }
4112       }
4113 
4114       // .../SymmetricMatrix<ZeroMatrix>
4115       {
4116          {
4117             using T1 = DynamicMatrix<int,rowMajor>;
4118             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
4119             using RT = ZeroMatrix<double,rowMajor>;
4120             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4121 
4122             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4123             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4124             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4125          }
4126          {
4127             using T1 = DynamicMatrix<int,rowMajor>;
4128             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
4129             using RT = ZeroMatrix<double,columnMajor>;
4130             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4131 
4132             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4133             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4134             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4135          }
4136          {
4137             using T1 = DynamicMatrix<int,columnMajor>;
4138             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
4139             using RT = ZeroMatrix<double,rowMajor>;
4140             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4141 
4142             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4143             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4144             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4145          }
4146          {
4147             using T1 = DynamicMatrix<int,columnMajor>;
4148             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
4149             using RT = ZeroMatrix<double,columnMajor>;
4150             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4151 
4152             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4153             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4154             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4155          }
4156       }
4157 
4158       // .../HermitianMatrix<DynamicMatrix> (symmetric)
4159       {
4160          {
4161             using T1 = DynamicMatrix<int,rowMajor>;
4162             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
4163             using RT = DynamicMatrix<double,rowMajor>;
4164             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4165 
4166             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4167             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4168             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4169          }
4170          {
4171             using T1 = DynamicMatrix<int,rowMajor>;
4172             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
4173             using RT = DynamicMatrix<double,columnMajor>;
4174             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4175 
4176             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4177             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4178             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4179          }
4180          {
4181             using T1 = DynamicMatrix<int,columnMajor>;
4182             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
4183             using RT = DynamicMatrix<double,rowMajor>;
4184             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4185 
4186             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4187             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4188             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4189          }
4190          {
4191             using T1 = DynamicMatrix<int,columnMajor>;
4192             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
4193             using RT = DynamicMatrix<double,columnMajor>;
4194             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4195 
4196             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4197             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4198             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4199          }
4200       }
4201 
4202       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
4203       {
4204          {
4205             using T1 = DynamicMatrix<int,rowMajor>;
4206             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
4207             using RT = DynamicMatrix<complex<int>,rowMajor>;
4208             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4209 
4210             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4211             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4212             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4213          }
4214          {
4215             using T1 = DynamicMatrix<int,rowMajor>;
4216             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
4217             using RT = DynamicMatrix<complex<int>,columnMajor>;
4218             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4219 
4220             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4221             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4222             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4223          }
4224          {
4225             using T1 = DynamicMatrix<int,columnMajor>;
4226             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
4227             using RT = DynamicMatrix<complex<int>,rowMajor>;
4228             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4229 
4230             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4231             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4232             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4233          }
4234          {
4235             using T1 = DynamicMatrix<int,columnMajor>;
4236             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
4237             using RT = DynamicMatrix<complex<int>,columnMajor>;
4238             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4239 
4240             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4241             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4242             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4243          }
4244       }
4245 
4246       // .../LowerMatrix<DynamicMatrix>
4247       {
4248          {
4249             using T1 = DynamicMatrix<int,rowMajor>;
4250             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
4251             using RT = DynamicMatrix<double,rowMajor>;
4252             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4253 
4254             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4255             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4256             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4257          }
4258          {
4259             using T1 = DynamicMatrix<int,rowMajor>;
4260             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
4261             using RT = DynamicMatrix<double,columnMajor>;
4262             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4263 
4264             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4265             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4266             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4267          }
4268          {
4269             using T1 = DynamicMatrix<int,columnMajor>;
4270             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
4271             using RT = DynamicMatrix<double,rowMajor>;
4272             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4273 
4274             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4275             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4276             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4277          }
4278          {
4279             using T1 = DynamicMatrix<int,columnMajor>;
4280             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
4281             using RT = DynamicMatrix<double,columnMajor>;
4282             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4283 
4284             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4285             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4286             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4287          }
4288       }
4289 
4290       // .../UniLowerMatrix<DynamicMatrix>
4291       {
4292          {
4293             using T1 = DynamicMatrix<int,rowMajor>;
4294             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
4295             using RT = DynamicMatrix<double,rowMajor>;
4296             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4297 
4298             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4299             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4300             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4301          }
4302          {
4303             using T1 = DynamicMatrix<int,rowMajor>;
4304             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
4305             using RT = DynamicMatrix<double,columnMajor>;
4306             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4307 
4308             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4309             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4310             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4311          }
4312          {
4313             using T1 = DynamicMatrix<int,columnMajor>;
4314             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
4315             using RT = DynamicMatrix<double,rowMajor>;
4316             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4317 
4318             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4319             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4320             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4321          }
4322          {
4323             using T1 = DynamicMatrix<int,columnMajor>;
4324             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
4325             using RT = DynamicMatrix<double,columnMajor>;
4326             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4327 
4328             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4329             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4330             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4331          }
4332       }
4333 
4334       // .../StrictlyLowerMatrix<DynamicMatrix>
4335       {
4336          {
4337             using T1 = DynamicMatrix<int,rowMajor>;
4338             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
4339             using RT = DynamicMatrix<double,rowMajor>;
4340             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4341 
4342             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4343             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4344             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4345          }
4346          {
4347             using T1 = DynamicMatrix<int,rowMajor>;
4348             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
4349             using RT = DynamicMatrix<double,columnMajor>;
4350             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4351 
4352             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4353             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4354             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4355          }
4356          {
4357             using T1 = DynamicMatrix<int,columnMajor>;
4358             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
4359             using RT = DynamicMatrix<double,rowMajor>;
4360             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4361 
4362             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4363             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4364             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4365          }
4366          {
4367             using T1 = DynamicMatrix<int,columnMajor>;
4368             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
4369             using RT = DynamicMatrix<double,columnMajor>;
4370             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4371 
4372             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4373             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4374             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4375          }
4376       }
4377 
4378       // .../UpperMatrix<DynamicMatrix>
4379       {
4380          {
4381             using T1 = DynamicMatrix<int,rowMajor>;
4382             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
4383             using RT = DynamicMatrix<double,rowMajor>;
4384             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4385 
4386             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4387             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4388             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4389          }
4390          {
4391             using T1 = DynamicMatrix<int,rowMajor>;
4392             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
4393             using RT = DynamicMatrix<double,columnMajor>;
4394             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4395 
4396             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4397             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4398             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4399          }
4400          {
4401             using T1 = DynamicMatrix<int,columnMajor>;
4402             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
4403             using RT = DynamicMatrix<double,rowMajor>;
4404             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4405 
4406             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4407             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4408             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4409          }
4410          {
4411             using T1 = DynamicMatrix<int,columnMajor>;
4412             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
4413             using RT = DynamicMatrix<double,columnMajor>;
4414             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4415 
4416             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4417             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4418             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4419          }
4420       }
4421 
4422       // .../UniUpperMatrix<DynamicMatrix>
4423       {
4424          {
4425             using T1 = DynamicMatrix<int,rowMajor>;
4426             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
4427             using RT = DynamicMatrix<double,rowMajor>;
4428             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4429 
4430             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4431             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4432             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4433          }
4434          {
4435             using T1 = DynamicMatrix<int,rowMajor>;
4436             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
4437             using RT = DynamicMatrix<double,columnMajor>;
4438             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4439 
4440             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4441             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4442             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4443          }
4444          {
4445             using T1 = DynamicMatrix<int,columnMajor>;
4446             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
4447             using RT = DynamicMatrix<double,rowMajor>;
4448             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4449 
4450             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4451             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4452             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4453          }
4454          {
4455             using T1 = DynamicMatrix<int,columnMajor>;
4456             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
4457             using RT = DynamicMatrix<double,columnMajor>;
4458             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4459 
4460             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4461             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4462             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4463          }
4464       }
4465 
4466       // .../StrictlyUpperMatrix<DynamicMatrix>
4467       {
4468          {
4469             using T1 = DynamicMatrix<int,rowMajor>;
4470             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
4471             using RT = DynamicMatrix<double,rowMajor>;
4472             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4473 
4474             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4475             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4476             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4477          }
4478          {
4479             using T1 = DynamicMatrix<int,rowMajor>;
4480             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
4481             using RT = DynamicMatrix<double,columnMajor>;
4482             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4483 
4484             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4485             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4486             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4487          }
4488          {
4489             using T1 = DynamicMatrix<int,columnMajor>;
4490             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
4491             using RT = DynamicMatrix<double,rowMajor>;
4492             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4493 
4494             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4495             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4496             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4497          }
4498          {
4499             using T1 = DynamicMatrix<int,columnMajor>;
4500             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
4501             using RT = DynamicMatrix<double,columnMajor>;
4502             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4503 
4504             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4505             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4506             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4507          }
4508       }
4509 
4510       // .../DiagonalMatrix<DynamicMatrix>
4511       {
4512          {
4513             using T1 = DynamicMatrix<int,rowMajor>;
4514             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
4515             using RT = DynamicMatrix<double,rowMajor>;
4516             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4517 
4518             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4519             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4520             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4521          }
4522          {
4523             using T1 = DynamicMatrix<int,rowMajor>;
4524             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
4525             using RT = DynamicMatrix<double,columnMajor>;
4526             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4527 
4528             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4529             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4530             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4531          }
4532          {
4533             using T1 = DynamicMatrix<int,columnMajor>;
4534             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
4535             using RT = DynamicMatrix<double,rowMajor>;
4536             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4537 
4538             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4539             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4540             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4541          }
4542          {
4543             using T1 = DynamicMatrix<int,columnMajor>;
4544             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
4545             using RT = DynamicMatrix<double,columnMajor>;
4546             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4547 
4548             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4549             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4550             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4551          }
4552       }
4553    }
4554 
4555    // CustomMatrix/...
4556    {
4557       // .../StaticMatrix
4558       {
4559          {
4560             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4561             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
4562             using RT = DynamicMatrix<double,rowMajor>;
4563             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4564 
4565             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4566             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4567             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4568          }
4569          {
4570             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4571             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
4572             using RT = DynamicMatrix<double,columnMajor>;
4573             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4574 
4575             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4576             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4577             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4578          }
4579          {
4580             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4581             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
4582             using RT = DynamicMatrix<double,rowMajor>;
4583             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4584 
4585             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4586             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4587             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4588          }
4589          {
4590             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4591             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
4592             using RT = DynamicMatrix<double,columnMajor>;
4593             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4594 
4595             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4596             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4597             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4598          }
4599       }
4600 
4601       // .../HybridMatrix
4602       {
4603          {
4604             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4605             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
4606             using RT = DynamicMatrix<double,rowMajor>;
4607             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4608 
4609             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4610             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4611             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4612          }
4613          {
4614             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4615             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
4616             using RT = DynamicMatrix<double,columnMajor>;
4617             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4618 
4619             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4620             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4621             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4622          }
4623          {
4624             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4625             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
4626             using RT = DynamicMatrix<double,rowMajor>;
4627             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4628 
4629             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4630             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4631             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4632          }
4633          {
4634             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4635             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
4636             using RT = DynamicMatrix<double,columnMajor>;
4637             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4638 
4639             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4640             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4641             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4642          }
4643       }
4644 
4645       // .../DynamicMatrix
4646       {
4647          {
4648             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4649             using T2 = DynamicMatrix<double,rowMajor>;
4650             using RT = DynamicMatrix<double,rowMajor>;
4651             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4652 
4653             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4654             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4655             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4656          }
4657          {
4658             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4659             using T2 = DynamicMatrix<double,columnMajor>;
4660             using RT = DynamicMatrix<double,columnMajor>;
4661             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4662 
4663             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4664             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4665             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4666          }
4667          {
4668             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4669             using T2 = DynamicMatrix<double,rowMajor>;
4670             using RT = DynamicMatrix<double,rowMajor>;
4671             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4672 
4673             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4674             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4675             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4676          }
4677          {
4678             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4679             using T2 = DynamicMatrix<double,columnMajor>;
4680             using RT = DynamicMatrix<double,columnMajor>;
4681             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4682 
4683             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4684             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4685             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4686          }
4687       }
4688 
4689       // .../CustomMatrix
4690       {
4691          {
4692             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4693             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
4694             using RT = DynamicMatrix<double,rowMajor>;
4695             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4696 
4697             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4698             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4699             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4700          }
4701          {
4702             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4703             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
4704             using RT = DynamicMatrix<double,columnMajor>;
4705             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4706 
4707             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4708             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4709             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4710          }
4711          {
4712             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4713             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
4714             using RT = DynamicMatrix<double,rowMajor>;
4715             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4716 
4717             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4718             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4719             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4720          }
4721          {
4722             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4723             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
4724             using RT = DynamicMatrix<double,columnMajor>;
4725             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4726 
4727             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4728             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4729             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4730          }
4731       }
4732 
4733       // .../UniformMatrix
4734       {
4735          {
4736             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4737             using T2 = UniformMatrix<double,rowMajor>;
4738             using RT = DynamicMatrix<double,rowMajor>;
4739             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4740 
4741             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4742             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4743             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4744          }
4745          {
4746             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4747             using T2 = UniformMatrix<double,columnMajor>;
4748             using RT = DynamicMatrix<double,columnMajor>;
4749             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4750 
4751             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4752             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4753             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4754          }
4755          {
4756             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4757             using T2 = UniformMatrix<double,rowMajor>;
4758             using RT = DynamicMatrix<double,rowMajor>;
4759             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4760 
4761             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4762             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4763             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4764          }
4765          {
4766             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4767             using T2 = UniformMatrix<double,columnMajor>;
4768             using RT = DynamicMatrix<double,columnMajor>;
4769             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4770 
4771             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4772             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4773             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4774          }
4775       }
4776 
4777       // .../InitializerMatrix
4778       {
4779          {
4780             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4781             using T2 = InitializerMatrix<double>;
4782             using RT = DynamicMatrix<double,rowMajor>;
4783             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4784 
4785             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4786             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4787             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4788          }
4789          {
4790             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4791             using T2 = InitializerMatrix<double>;
4792             using RT = DynamicMatrix<double,rowMajor>;
4793             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4794 
4795             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4796             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4797             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4798          }
4799       }
4800 
4801       // .../CompressedMatrix
4802       {
4803          {
4804             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4805             using T2 = CompressedMatrix<double,rowMajor>;
4806             using RT = CompressedMatrix<double,rowMajor>;
4807             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4808 
4809             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4810             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4811             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4812          }
4813          {
4814             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4815             using T2 = CompressedMatrix<double,columnMajor>;
4816             using RT = CompressedMatrix<double,columnMajor>;
4817             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4818 
4819             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4820             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4821             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4822          }
4823          {
4824             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4825             using T2 = CompressedMatrix<double,rowMajor>;
4826             using RT = CompressedMatrix<double,rowMajor>;
4827             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4828 
4829             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4830             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4831             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4832          }
4833          {
4834             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4835             using T2 = CompressedMatrix<double,columnMajor>;
4836             using RT = CompressedMatrix<double,columnMajor>;
4837             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4838 
4839             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4840             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4841             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4842          }
4843       }
4844 
4845       // .../IdentityMatrix
4846       {
4847          {
4848             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4849             using T2 = IdentityMatrix<double,rowMajor>;
4850             using RT = CompressedMatrix<double,rowMajor>;
4851             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4852 
4853             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4854             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4855             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4856          }
4857          {
4858             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4859             using T2 = IdentityMatrix<double,columnMajor>;
4860             using RT = CompressedMatrix<double,columnMajor>;
4861             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4862 
4863             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4864             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4865             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4866          }
4867          {
4868             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4869             using T2 = IdentityMatrix<double,rowMajor>;
4870             using RT = CompressedMatrix<double,rowMajor>;
4871             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4872 
4873             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4874             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4875             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4876          }
4877          {
4878             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4879             using T2 = IdentityMatrix<double,columnMajor>;
4880             using RT = CompressedMatrix<double,columnMajor>;
4881             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4882 
4883             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4884             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4885             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4886          }
4887       }
4888 
4889       // .../ZeroMatrix
4890       {
4891          {
4892             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4893             using T2 = ZeroMatrix<double,rowMajor>;
4894             using RT = ZeroMatrix<double,rowMajor>;
4895             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4896 
4897             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4898             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4899             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4900          }
4901          {
4902             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4903             using T2 = ZeroMatrix<double,columnMajor>;
4904             using RT = ZeroMatrix<double,columnMajor>;
4905             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4906 
4907             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4908             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4909             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4910          }
4911          {
4912             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4913             using T2 = ZeroMatrix<double,rowMajor>;
4914             using RT = ZeroMatrix<double,rowMajor>;
4915             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4916 
4917             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4918             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4919             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4920          }
4921          {
4922             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4923             using T2 = ZeroMatrix<double,columnMajor>;
4924             using RT = ZeroMatrix<double,columnMajor>;
4925             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4926 
4927             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4928             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4929             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4930          }
4931       }
4932 
4933       // .../SymmetricMatrix<DynamicMatrix> (real)
4934       {
4935          {
4936             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4937             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
4938             using RT = DynamicMatrix<double,rowMajor>;
4939             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4940 
4941             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4942             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4943             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4944          }
4945          {
4946             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4947             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
4948             using RT = DynamicMatrix<double,columnMajor>;
4949             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4950 
4951             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4952             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4953             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4954          }
4955          {
4956             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4957             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
4958             using RT = DynamicMatrix<double,rowMajor>;
4959             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4960 
4961             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4962             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4963             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4964          }
4965          {
4966             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
4967             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
4968             using RT = DynamicMatrix<double,columnMajor>;
4969             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4970 
4971             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4972             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4973             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4974          }
4975       }
4976 
4977       // .../SymmetricMatrix<DynamicMatrix> (complex)
4978       {
4979          {
4980             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4981             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
4982             using RT = DynamicMatrix<complex<int>,rowMajor>;
4983             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4984 
4985             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4986             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4987             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4988          }
4989          {
4990             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
4991             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
4992             using RT = DynamicMatrix<complex<int>,columnMajor>;
4993             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
4994 
4995             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
4996             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
4997             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
4998          }
4999          {
5000             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5001             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
5002             using RT = DynamicMatrix<complex<int>,rowMajor>;
5003             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5004 
5005             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5006             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5007             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5008          }
5009          {
5010             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5011             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
5012             using RT = DynamicMatrix<complex<int>,columnMajor>;
5013             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5014 
5015             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5016             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5017             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5018          }
5019       }
5020 
5021       // .../SymmetricMatrix<UniformMatrix>
5022       {
5023          {
5024             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5025             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
5026             using RT = DynamicMatrix<double,rowMajor>;
5027             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5028 
5029             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5030             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5031             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5032          }
5033          {
5034             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5035             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
5036             using RT = DynamicMatrix<double,columnMajor>;
5037             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5038 
5039             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5040             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5041             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5042          }
5043          {
5044             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5045             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
5046             using RT = DynamicMatrix<double,rowMajor>;
5047             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5048 
5049             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5050             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5051             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5052          }
5053          {
5054             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5055             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
5056             using RT = DynamicMatrix<double,columnMajor>;
5057             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5058 
5059             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5060             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5061             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5062          }
5063       }
5064 
5065       // .../SymmetricMatrix<ZeroMatrix>
5066       {
5067          {
5068             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5069             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
5070             using RT = ZeroMatrix<double,rowMajor>;
5071             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5072 
5073             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5074             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5075             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5076          }
5077          {
5078             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5079             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
5080             using RT = ZeroMatrix<double,columnMajor>;
5081             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5082 
5083             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5084             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5085             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5086          }
5087          {
5088             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5089             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
5090             using RT = ZeroMatrix<double,rowMajor>;
5091             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5092 
5093             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5094             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5095             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5096          }
5097          {
5098             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5099             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
5100             using RT = ZeroMatrix<double,columnMajor>;
5101             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5102 
5103             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5104             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5105             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5106          }
5107       }
5108 
5109       // .../HermitianMatrix<DynamicMatrix> (symmetric)
5110       {
5111          {
5112             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5113             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
5114             using RT = DynamicMatrix<double,rowMajor>;
5115             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5116 
5117             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5118             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5119             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5120          }
5121          {
5122             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5123             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
5124             using RT = DynamicMatrix<double,columnMajor>;
5125             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5126 
5127             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5128             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5129             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5130          }
5131          {
5132             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5133             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
5134             using RT = DynamicMatrix<double,rowMajor>;
5135             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5136 
5137             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5138             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5139             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5140          }
5141          {
5142             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5143             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
5144             using RT = DynamicMatrix<double,columnMajor>;
5145             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5146 
5147             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5148             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5149             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5150          }
5151       }
5152 
5153       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
5154       {
5155          {
5156             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5157             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
5158             using RT = DynamicMatrix<complex<int>,rowMajor>;
5159             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5160 
5161             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5162             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5163             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5164          }
5165          {
5166             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5167             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
5168             using RT = DynamicMatrix<complex<int>,columnMajor>;
5169             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5170 
5171             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5172             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5173             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5174          }
5175          {
5176             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5177             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
5178             using RT = DynamicMatrix<complex<int>,rowMajor>;
5179             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5180 
5181             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5182             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5183             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5184          }
5185          {
5186             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5187             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
5188             using RT = DynamicMatrix<complex<int>,columnMajor>;
5189             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5190 
5191             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5192             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5193             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5194          }
5195       }
5196 
5197       // .../LowerMatrix<DynamicMatrix>
5198       {
5199          {
5200             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5201             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
5202             using RT = DynamicMatrix<double,rowMajor>;
5203             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5204 
5205             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5206             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5207             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5208          }
5209          {
5210             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5211             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
5212             using RT = DynamicMatrix<double,columnMajor>;
5213             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5214 
5215             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5216             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5217             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5218          }
5219          {
5220             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5221             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
5222             using RT = DynamicMatrix<double,rowMajor>;
5223             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5224 
5225             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5226             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5227             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5228          }
5229          {
5230             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5231             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
5232             using RT = DynamicMatrix<double,columnMajor>;
5233             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5234 
5235             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5236             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5237             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5238          }
5239       }
5240 
5241       // .../UniLowerMatrix<DynamicMatrix>
5242       {
5243          {
5244             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5245             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
5246             using RT = DynamicMatrix<double,rowMajor>;
5247             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5248 
5249             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5250             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5251             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5252          }
5253          {
5254             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5255             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
5256             using RT = DynamicMatrix<double,columnMajor>;
5257             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5258 
5259             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5260             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5261             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5262          }
5263          {
5264             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5265             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
5266             using RT = DynamicMatrix<double,rowMajor>;
5267             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5268 
5269             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5270             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5271             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5272          }
5273          {
5274             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5275             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
5276             using RT = DynamicMatrix<double,columnMajor>;
5277             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5278 
5279             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5280             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5281             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5282          }
5283       }
5284 
5285       // .../StrictlyLowerMatrix<DynamicMatrix>
5286       {
5287          {
5288             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5289             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
5290             using RT = DynamicMatrix<double,rowMajor>;
5291             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5292 
5293             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5294             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5295             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5296          }
5297          {
5298             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5299             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
5300             using RT = DynamicMatrix<double,columnMajor>;
5301             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5302 
5303             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5304             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5305             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5306          }
5307          {
5308             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5309             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
5310             using RT = DynamicMatrix<double,rowMajor>;
5311             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5312 
5313             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5314             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5315             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5316          }
5317          {
5318             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5319             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
5320             using RT = DynamicMatrix<double,columnMajor>;
5321             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5322 
5323             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5324             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5325             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5326          }
5327       }
5328 
5329       // .../UpperMatrix<DynamicMatrix>
5330       {
5331          {
5332             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5333             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
5334             using RT = DynamicMatrix<double,rowMajor>;
5335             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5336 
5337             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5338             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5339             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5340          }
5341          {
5342             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5343             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
5344             using RT = DynamicMatrix<double,columnMajor>;
5345             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5346 
5347             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5348             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5349             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5350          }
5351          {
5352             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5353             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
5354             using RT = DynamicMatrix<double,rowMajor>;
5355             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5356 
5357             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5358             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5359             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5360          }
5361          {
5362             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5363             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
5364             using RT = DynamicMatrix<double,columnMajor>;
5365             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5366 
5367             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5368             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5369             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5370          }
5371       }
5372 
5373       // .../UniUpperMatrix<DynamicMatrix>
5374       {
5375          {
5376             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5377             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
5378             using RT = DynamicMatrix<double,rowMajor>;
5379             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5380 
5381             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5382             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5383             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5384          }
5385          {
5386             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5387             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
5388             using RT = DynamicMatrix<double,columnMajor>;
5389             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5390 
5391             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5392             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5393             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5394          }
5395          {
5396             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5397             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
5398             using RT = DynamicMatrix<double,rowMajor>;
5399             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5400 
5401             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5402             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5403             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5404          }
5405          {
5406             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5407             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
5408             using RT = DynamicMatrix<double,columnMajor>;
5409             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5410 
5411             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5412             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5413             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5414          }
5415       }
5416 
5417       // .../StrictlyUpperMatrix<DynamicMatrix>
5418       {
5419          {
5420             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5421             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
5422             using RT = DynamicMatrix<double,rowMajor>;
5423             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5424 
5425             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5426             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5427             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5428          }
5429          {
5430             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5431             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
5432             using RT = DynamicMatrix<double,columnMajor>;
5433             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5434 
5435             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5436             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5437             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5438          }
5439          {
5440             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5441             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
5442             using RT = DynamicMatrix<double,rowMajor>;
5443             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5444 
5445             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5446             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5447             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5448          }
5449          {
5450             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5451             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
5452             using RT = DynamicMatrix<double,columnMajor>;
5453             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5454 
5455             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5456             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5457             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5458          }
5459       }
5460 
5461       // .../DiagonalMatrix<DynamicMatrix>
5462       {
5463          {
5464             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5465             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
5466             using RT = DynamicMatrix<double,rowMajor>;
5467             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5468 
5469             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5470             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5471             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5472          }
5473          {
5474             using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
5475             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
5476             using RT = DynamicMatrix<double,columnMajor>;
5477             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5478 
5479             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5480             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5481             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5482          }
5483          {
5484             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5485             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
5486             using RT = DynamicMatrix<double,rowMajor>;
5487             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5488 
5489             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5490             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5491             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5492          }
5493          {
5494             using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
5495             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
5496             using RT = DynamicMatrix<double,columnMajor>;
5497             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5498 
5499             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5500             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5501             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5502          }
5503       }
5504    }
5505 
5506    // UniformMatrix/...
5507    {
5508       // .../StaticMatrix
5509       {
5510          {
5511             using T1 = UniformMatrix<int,rowMajor>;
5512             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
5513             using RT = DynamicMatrix<double,rowMajor>;
5514             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5515 
5516             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5517             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5518             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5519          }
5520          {
5521             using T1 = UniformMatrix<int,rowMajor>;
5522             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
5523             using RT = DynamicMatrix<double,columnMajor>;
5524             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5525 
5526             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5527             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5528             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5529          }
5530          {
5531             using T1 = UniformMatrix<int,columnMajor>;
5532             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
5533             using RT = DynamicMatrix<double,rowMajor>;
5534             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5535 
5536             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5537             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5538             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5539          }
5540          {
5541             using T1 = UniformMatrix<int,columnMajor>;
5542             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
5543             using RT = DynamicMatrix<double,columnMajor>;
5544             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5545 
5546             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5547             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5548             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5549          }
5550       }
5551 
5552       // .../HybridMatrix
5553       {
5554          {
5555             using T1 = UniformMatrix<int,rowMajor>;
5556             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
5557             using RT = DynamicMatrix<double,rowMajor>;
5558             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5559 
5560             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5561             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5562             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5563          }
5564          {
5565             using T1 = UniformMatrix<int,rowMajor>;
5566             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
5567             using RT = DynamicMatrix<double,columnMajor>;
5568             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5569 
5570             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5571             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5572             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5573          }
5574          {
5575             using T1 = UniformMatrix<int,columnMajor>;
5576             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
5577             using RT = DynamicMatrix<double,rowMajor>;
5578             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5579 
5580             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5581             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5582             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5583          }
5584          {
5585             using T1 = UniformMatrix<int,columnMajor>;
5586             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
5587             using RT = DynamicMatrix<double,columnMajor>;
5588             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5589 
5590             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5591             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5592             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5593          }
5594       }
5595 
5596       // .../DynamicMatrix
5597       {
5598          {
5599             using T1 = UniformMatrix<int,rowMajor>;
5600             using T2 = DynamicMatrix<double,rowMajor>;
5601             using RT = DynamicMatrix<double,rowMajor>;
5602             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5603 
5604             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5605             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5606             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5607          }
5608          {
5609             using T1 = UniformMatrix<int,rowMajor>;
5610             using T2 = DynamicMatrix<double,columnMajor>;
5611             using RT = DynamicMatrix<double,columnMajor>;
5612             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5613 
5614             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5615             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5616             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5617          }
5618          {
5619             using T1 = UniformMatrix<int,columnMajor>;
5620             using T2 = DynamicMatrix<double,rowMajor>;
5621             using RT = DynamicMatrix<double,rowMajor>;
5622             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5623 
5624             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5625             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5626             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5627          }
5628          {
5629             using T1 = UniformMatrix<int,columnMajor>;
5630             using T2 = DynamicMatrix<double,columnMajor>;
5631             using RT = DynamicMatrix<double,columnMajor>;
5632             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5633 
5634             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5635             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5636             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5637          }
5638       }
5639 
5640       // .../CustomMatrix
5641       {
5642          {
5643             using T1 = UniformMatrix<int,rowMajor>;
5644             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
5645             using RT = DynamicMatrix<double,rowMajor>;
5646             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5647 
5648             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5649             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5650             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5651          }
5652          {
5653             using T1 = UniformMatrix<int,rowMajor>;
5654             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
5655             using RT = DynamicMatrix<double,columnMajor>;
5656             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5657 
5658             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5659             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5660             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5661          }
5662          {
5663             using T1 = UniformMatrix<int,columnMajor>;
5664             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
5665             using RT = DynamicMatrix<double,rowMajor>;
5666             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5667 
5668             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5669             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5670             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5671          }
5672          {
5673             using T1 = UniformMatrix<int,columnMajor>;
5674             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
5675             using RT = DynamicMatrix<double,columnMajor>;
5676             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5677 
5678             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5679             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5680             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5681          }
5682       }
5683 
5684       // .../UniformMatrix
5685       {
5686          {
5687             using T1 = UniformMatrix<int,rowMajor>;
5688             using T2 = UniformMatrix<double,rowMajor>;
5689             using RT = UniformMatrix<double,rowMajor>;
5690             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5691 
5692             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5693             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5694             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5695          }
5696          {
5697             using T1 = UniformMatrix<int,rowMajor>;
5698             using T2 = UniformMatrix<double,columnMajor>;
5699             using RT = UniformMatrix<double,columnMajor>;
5700             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5701 
5702             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5703             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5704             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5705          }
5706          {
5707             using T1 = UniformMatrix<int,columnMajor>;
5708             using T2 = UniformMatrix<double,rowMajor>;
5709             using RT = UniformMatrix<double,rowMajor>;
5710             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5711 
5712             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5713             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5714             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5715          }
5716          {
5717             using T1 = UniformMatrix<int,columnMajor>;
5718             using T2 = UniformMatrix<double,columnMajor>;
5719             using RT = UniformMatrix<double,columnMajor>;
5720             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5721 
5722             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5723             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5724             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5725          }
5726       }
5727 
5728       // .../InitializerMatrix
5729       {
5730          {
5731             using T1 = UniformMatrix<int,rowMajor>;
5732             using T2 = InitializerMatrix<double>;
5733             using RT = DynamicMatrix<double,rowMajor>;
5734             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5735 
5736             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5737             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5738             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5739          }
5740          {
5741             using T1 = UniformMatrix<int,columnMajor>;
5742             using T2 = InitializerMatrix<double>;
5743             using RT = DynamicMatrix<double,rowMajor>;
5744             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5745 
5746             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5747             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5748             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5749          }
5750       }
5751 
5752       // .../CompressedMatrix
5753       {
5754          {
5755             using T1 = UniformMatrix<int,rowMajor>;
5756             using T2 = CompressedMatrix<double,rowMajor>;
5757             using RT = CompressedMatrix<double,rowMajor>;
5758             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5759 
5760             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5761             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5762             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5763          }
5764          {
5765             using T1 = UniformMatrix<int,rowMajor>;
5766             using T2 = CompressedMatrix<double,columnMajor>;
5767             using RT = CompressedMatrix<double,columnMajor>;
5768             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5769 
5770             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5771             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5772             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5773          }
5774          {
5775             using T1 = UniformMatrix<int,columnMajor>;
5776             using T2 = CompressedMatrix<double,rowMajor>;
5777             using RT = CompressedMatrix<double,rowMajor>;
5778             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5779 
5780             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5781             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5782             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5783          }
5784          {
5785             using T1 = UniformMatrix<int,columnMajor>;
5786             using T2 = CompressedMatrix<double,columnMajor>;
5787             using RT = CompressedMatrix<double,columnMajor>;
5788             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5789 
5790             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5791             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5792             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5793          }
5794       }
5795 
5796       // .../IdentityMatrix
5797       {
5798          {
5799             using T1 = UniformMatrix<int,rowMajor>;
5800             using T2 = IdentityMatrix<double,rowMajor>;
5801             using RT = CompressedMatrix<double,rowMajor>;
5802             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5803 
5804             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5805             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5806             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5807          }
5808          {
5809             using T1 = UniformMatrix<int,rowMajor>;
5810             using T2 = IdentityMatrix<double,columnMajor>;
5811             using RT = CompressedMatrix<double,columnMajor>;
5812             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5813 
5814             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5815             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5816             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5817          }
5818          {
5819             using T1 = UniformMatrix<int,columnMajor>;
5820             using T2 = IdentityMatrix<double,rowMajor>;
5821             using RT = CompressedMatrix<double,rowMajor>;
5822             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5823 
5824             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5825             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5826             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5827          }
5828          {
5829             using T1 = UniformMatrix<int,columnMajor>;
5830             using T2 = IdentityMatrix<double,columnMajor>;
5831             using RT = CompressedMatrix<double,columnMajor>;
5832             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5833 
5834             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5835             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5836             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5837          }
5838       }
5839 
5840       // .../ZeroMatrix
5841       {
5842          {
5843             using T1 = UniformMatrix<int,rowMajor>;
5844             using T2 = ZeroMatrix<double,rowMajor>;
5845             using RT = ZeroMatrix<double,rowMajor>;
5846             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5847 
5848             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5849             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5850             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5851          }
5852          {
5853             using T1 = UniformMatrix<int,rowMajor>;
5854             using T2 = ZeroMatrix<double,columnMajor>;
5855             using RT = ZeroMatrix<double,columnMajor>;
5856             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5857 
5858             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5859             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5860             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5861          }
5862          {
5863             using T1 = UniformMatrix<int,columnMajor>;
5864             using T2 = ZeroMatrix<double,rowMajor>;
5865             using RT = ZeroMatrix<double,rowMajor>;
5866             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5867 
5868             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5869             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5870             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5871          }
5872          {
5873             using T1 = UniformMatrix<int,columnMajor>;
5874             using T2 = ZeroMatrix<double,columnMajor>;
5875             using RT = ZeroMatrix<double,columnMajor>;
5876             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5877 
5878             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5879             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5880             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5881          }
5882       }
5883 
5884       // .../SymmetricMatrix<DynamicMatrix> (real)
5885       {
5886          {
5887             using T1 = UniformMatrix<int,rowMajor>;
5888             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
5889             using RT = DynamicMatrix<double,rowMajor>;
5890             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5891 
5892             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5893             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5894             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5895          }
5896          {
5897             using T1 = UniformMatrix<int,rowMajor>;
5898             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
5899             using RT = DynamicMatrix<double,columnMajor>;
5900             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5901 
5902             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5903             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5904             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5905          }
5906          {
5907             using T1 = UniformMatrix<int,columnMajor>;
5908             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
5909             using RT = DynamicMatrix<double,rowMajor>;
5910             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5911 
5912             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5913             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5914             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5915          }
5916          {
5917             using T1 = UniformMatrix<int,columnMajor>;
5918             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
5919             using RT = DynamicMatrix<double,columnMajor>;
5920             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5921 
5922             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5923             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5924             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5925          }
5926       }
5927 
5928       // .../SymmetricMatrix<DynamicMatrix> (complex)
5929       {
5930          {
5931             using T1 = UniformMatrix<int,rowMajor>;
5932             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
5933             using RT = DynamicMatrix<complex<int>,rowMajor>;
5934             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5935 
5936             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5937             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5938             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5939          }
5940          {
5941             using T1 = UniformMatrix<int,rowMajor>;
5942             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
5943             using RT = DynamicMatrix<complex<int>,columnMajor>;
5944             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5945 
5946             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5947             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5948             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5949          }
5950          {
5951             using T1 = UniformMatrix<int,columnMajor>;
5952             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
5953             using RT = DynamicMatrix<complex<int>,rowMajor>;
5954             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5955 
5956             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5957             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5958             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5959          }
5960          {
5961             using T1 = UniformMatrix<int,columnMajor>;
5962             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
5963             using RT = DynamicMatrix<complex<int>,columnMajor>;
5964             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5965 
5966             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5967             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5968             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5969          }
5970       }
5971 
5972       // .../SymmetricMatrix<UniformMatrix>
5973       {
5974          {
5975             using T1 = UniformMatrix<int,rowMajor>;
5976             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
5977             using RT = UniformMatrix<double,rowMajor>;
5978             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5979 
5980             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5981             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5982             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5983          }
5984          {
5985             using T1 = UniformMatrix<int,rowMajor>;
5986             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
5987             using RT = UniformMatrix<double,columnMajor>;
5988             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5989 
5990             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
5991             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
5992             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
5993          }
5994          {
5995             using T1 = UniformMatrix<int,columnMajor>;
5996             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
5997             using RT = UniformMatrix<double,rowMajor>;
5998             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
5999 
6000             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6001             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6002             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6003          }
6004          {
6005             using T1 = UniformMatrix<int,columnMajor>;
6006             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
6007             using RT = UniformMatrix<double,columnMajor>;
6008             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6009 
6010             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6011             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6012             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6013          }
6014       }
6015 
6016       // .../SymmetricMatrix<ZeroMatrix>
6017       {
6018          {
6019             using T1 = UniformMatrix<int,rowMajor>;
6020             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
6021             using RT = ZeroMatrix<double,rowMajor>;
6022             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6023 
6024             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6025             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6026             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6027          }
6028          {
6029             using T1 = UniformMatrix<int,rowMajor>;
6030             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
6031             using RT = ZeroMatrix<double,columnMajor>;
6032             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6033 
6034             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6035             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6036             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6037          }
6038          {
6039             using T1 = UniformMatrix<int,columnMajor>;
6040             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
6041             using RT = ZeroMatrix<double,rowMajor>;
6042             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6043 
6044             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6045             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6046             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6047          }
6048          {
6049             using T1 = UniformMatrix<int,columnMajor>;
6050             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
6051             using RT = ZeroMatrix<double,columnMajor>;
6052             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6053 
6054             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6055             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6056             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6057          }
6058       }
6059 
6060       // .../HermitianMatrix<DynamicMatrix> (symmetric)
6061       {
6062          {
6063             using T1 = UniformMatrix<int,rowMajor>;
6064             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
6065             using RT = DynamicMatrix<double,rowMajor>;
6066             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6067 
6068             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6069             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6070             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6071          }
6072          {
6073             using T1 = UniformMatrix<int,rowMajor>;
6074             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
6075             using RT = DynamicMatrix<double,columnMajor>;
6076             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6077 
6078             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6079             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6080             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6081          }
6082          {
6083             using T1 = UniformMatrix<int,columnMajor>;
6084             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
6085             using RT = DynamicMatrix<double,rowMajor>;
6086             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6087 
6088             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6089             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6090             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6091          }
6092          {
6093             using T1 = UniformMatrix<int,columnMajor>;
6094             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
6095             using RT = DynamicMatrix<double,columnMajor>;
6096             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6097 
6098             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6099             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6100             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6101          }
6102       }
6103 
6104       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
6105       {
6106          {
6107             using T1 = UniformMatrix<int,rowMajor>;
6108             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
6109             using RT = DynamicMatrix<complex<int>,rowMajor>;
6110             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6111 
6112             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6113             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6114             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6115          }
6116          {
6117             using T1 = UniformMatrix<int,rowMajor>;
6118             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
6119             using RT = DynamicMatrix<complex<int>,columnMajor>;
6120             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6121 
6122             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6123             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6124             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6125          }
6126          {
6127             using T1 = UniformMatrix<int,columnMajor>;
6128             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
6129             using RT = DynamicMatrix<complex<int>,rowMajor>;
6130             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6131 
6132             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6133             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6134             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6135          }
6136          {
6137             using T1 = UniformMatrix<int,columnMajor>;
6138             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
6139             using RT = DynamicMatrix<complex<int>,columnMajor>;
6140             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6141 
6142             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6143             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6144             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6145          }
6146       }
6147 
6148       // .../LowerMatrix<DynamicMatrix>
6149       {
6150          {
6151             using T1 = UniformMatrix<int,rowMajor>;
6152             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
6153             using RT = DynamicMatrix<double,rowMajor>;
6154             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6155 
6156             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6157             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6158             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6159          }
6160          {
6161             using T1 = UniformMatrix<int,rowMajor>;
6162             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
6163             using RT = DynamicMatrix<double,columnMajor>;
6164             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6165 
6166             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6167             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6168             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6169          }
6170          {
6171             using T1 = UniformMatrix<int,columnMajor>;
6172             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
6173             using RT = DynamicMatrix<double,rowMajor>;
6174             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6175 
6176             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6177             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6178             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6179          }
6180          {
6181             using T1 = UniformMatrix<int,columnMajor>;
6182             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
6183             using RT = DynamicMatrix<double,columnMajor>;
6184             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6185 
6186             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6187             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6188             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6189          }
6190       }
6191 
6192       // .../UniLowerMatrix<DynamicMatrix>
6193       {
6194          {
6195             using T1 = UniformMatrix<int,rowMajor>;
6196             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
6197             using RT = DynamicMatrix<double,rowMajor>;
6198             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6199 
6200             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6201             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6202             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6203          }
6204          {
6205             using T1 = UniformMatrix<int,rowMajor>;
6206             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
6207             using RT = DynamicMatrix<double,columnMajor>;
6208             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6209 
6210             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6211             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6212             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6213          }
6214          {
6215             using T1 = UniformMatrix<int,columnMajor>;
6216             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
6217             using RT = DynamicMatrix<double,rowMajor>;
6218             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6219 
6220             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6221             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6222             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6223          }
6224          {
6225             using T1 = UniformMatrix<int,columnMajor>;
6226             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
6227             using RT = DynamicMatrix<double,columnMajor>;
6228             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6229 
6230             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6231             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6232             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6233          }
6234       }
6235 
6236       // .../StrictlyLowerMatrix<DynamicMatrix>
6237       {
6238          {
6239             using T1 = UniformMatrix<int,rowMajor>;
6240             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
6241             using RT = DynamicMatrix<double,rowMajor>;
6242             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6243 
6244             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6245             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6246             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6247          }
6248          {
6249             using T1 = UniformMatrix<int,rowMajor>;
6250             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
6251             using RT = DynamicMatrix<double,columnMajor>;
6252             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6253 
6254             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6255             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6256             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6257          }
6258          {
6259             using T1 = UniformMatrix<int,columnMajor>;
6260             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
6261             using RT = DynamicMatrix<double,rowMajor>;
6262             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6263 
6264             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6265             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6266             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6267          }
6268          {
6269             using T1 = UniformMatrix<int,columnMajor>;
6270             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
6271             using RT = DynamicMatrix<double,columnMajor>;
6272             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6273 
6274             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6275             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6276             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6277          }
6278       }
6279 
6280       // .../UpperMatrix<DynamicMatrix>
6281       {
6282          {
6283             using T1 = UniformMatrix<int,rowMajor>;
6284             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
6285             using RT = DynamicMatrix<double,rowMajor>;
6286             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6287 
6288             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6289             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6290             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6291          }
6292          {
6293             using T1 = UniformMatrix<int,rowMajor>;
6294             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
6295             using RT = DynamicMatrix<double,columnMajor>;
6296             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6297 
6298             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6299             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6300             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6301          }
6302          {
6303             using T1 = UniformMatrix<int,columnMajor>;
6304             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
6305             using RT = DynamicMatrix<double,rowMajor>;
6306             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6307 
6308             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6309             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6310             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6311          }
6312          {
6313             using T1 = UniformMatrix<int,columnMajor>;
6314             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
6315             using RT = DynamicMatrix<double,columnMajor>;
6316             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6317 
6318             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6319             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6320             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6321          }
6322       }
6323 
6324       // .../UniUpperMatrix<DynamicMatrix>
6325       {
6326          {
6327             using T1 = UniformMatrix<int,rowMajor>;
6328             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
6329             using RT = DynamicMatrix<double,rowMajor>;
6330             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6331 
6332             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6333             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6334             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6335          }
6336          {
6337             using T1 = UniformMatrix<int,rowMajor>;
6338             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
6339             using RT = DynamicMatrix<double,columnMajor>;
6340             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6341 
6342             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6343             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6344             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6345          }
6346          {
6347             using T1 = UniformMatrix<int,columnMajor>;
6348             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
6349             using RT = DynamicMatrix<double,rowMajor>;
6350             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6351 
6352             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6353             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6354             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6355          }
6356          {
6357             using T1 = UniformMatrix<int,columnMajor>;
6358             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
6359             using RT = DynamicMatrix<double,columnMajor>;
6360             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6361 
6362             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6363             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6364             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6365          }
6366       }
6367 
6368       // .../StrictlyUpperMatrix<DynamicMatrix>
6369       {
6370          {
6371             using T1 = UniformMatrix<int,rowMajor>;
6372             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
6373             using RT = DynamicMatrix<double,rowMajor>;
6374             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6375 
6376             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6377             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6378             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6379          }
6380          {
6381             using T1 = UniformMatrix<int,rowMajor>;
6382             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
6383             using RT = DynamicMatrix<double,columnMajor>;
6384             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6385 
6386             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6387             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6388             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6389          }
6390          {
6391             using T1 = UniformMatrix<int,columnMajor>;
6392             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
6393             using RT = DynamicMatrix<double,rowMajor>;
6394             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6395 
6396             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6397             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6398             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6399          }
6400          {
6401             using T1 = UniformMatrix<int,columnMajor>;
6402             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
6403             using RT = DynamicMatrix<double,columnMajor>;
6404             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6405 
6406             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6407             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6408             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6409          }
6410       }
6411 
6412       // .../DiagonalMatrix<DynamicMatrix>
6413       {
6414          {
6415             using T1 = UniformMatrix<int,rowMajor>;
6416             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
6417             using RT = DynamicMatrix<double,rowMajor>;
6418             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6419 
6420             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6421             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6422             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6423          }
6424          {
6425             using T1 = UniformMatrix<int,rowMajor>;
6426             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
6427             using RT = DynamicMatrix<double,columnMajor>;
6428             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6429 
6430             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6431             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6432             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6433          }
6434          {
6435             using T1 = UniformMatrix<int,columnMajor>;
6436             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
6437             using RT = DynamicMatrix<double,rowMajor>;
6438             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6439 
6440             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6441             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6442             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6443          }
6444          {
6445             using T1 = UniformMatrix<int,columnMajor>;
6446             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
6447             using RT = DynamicMatrix<double,columnMajor>;
6448             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6449 
6450             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6451             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6452             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6453          }
6454       }
6455    }
6456 
6457    // InitializerMatrix/...
6458    {
6459       // .../StaticMatrix
6460       {
6461          {
6462             using T1 = InitializerMatrix<int>;
6463             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
6464             using RT = DynamicMatrix<double,rowMajor>;
6465             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6466 
6467             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6468             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6469             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6470          }
6471          {
6472             using T1 = InitializerMatrix<int>;
6473             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
6474             using RT = DynamicMatrix<double,columnMajor>;
6475             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6476 
6477             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6478             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6479             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6480          }
6481       }
6482 
6483       // .../HybridMatrix
6484       {
6485          {
6486             using T1 = InitializerMatrix<int>;
6487             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
6488             using RT = DynamicMatrix<double,rowMajor>;
6489             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6490 
6491             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6492             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6493             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6494          }
6495          {
6496             using T1 = InitializerMatrix<int>;
6497             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
6498             using RT = DynamicMatrix<double,columnMajor>;
6499             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6500 
6501             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6502             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6503             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6504          }
6505       }
6506 
6507       // .../DynamicMatrix
6508       {
6509          {
6510             using T1 = InitializerMatrix<int>;
6511             using T2 = DynamicMatrix<double,rowMajor>;
6512             using RT = DynamicMatrix<double,rowMajor>;
6513             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6514 
6515             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6516             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6517             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6518          }
6519          {
6520             using T1 = InitializerMatrix<int>;
6521             using T2 = DynamicMatrix<double,columnMajor>;
6522             using RT = DynamicMatrix<double,columnMajor>;
6523             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6524 
6525             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6526             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6527             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6528          }
6529       }
6530 
6531       // .../CustomMatrix
6532       {
6533          {
6534             using T1 = InitializerMatrix<int>;
6535             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
6536             using RT = DynamicMatrix<double,rowMajor>;
6537             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6538 
6539             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6540             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6541             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6542          }
6543          {
6544             using T1 = InitializerMatrix<int>;
6545             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
6546             using RT = DynamicMatrix<double,columnMajor>;
6547             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6548 
6549             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6550             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6551             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6552          }
6553       }
6554 
6555       // .../UniformMatrix
6556       {
6557          {
6558             using T1 = InitializerMatrix<int>;
6559             using T2 = UniformMatrix<double,rowMajor>;
6560             using RT = DynamicMatrix<double,rowMajor>;
6561             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6562 
6563             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6564             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6565             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6566          }
6567          {
6568             using T1 = InitializerMatrix<int>;
6569             using T2 = UniformMatrix<double,columnMajor>;
6570             using RT = DynamicMatrix<double,columnMajor>;
6571             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6572 
6573             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6574             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6575             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6576          }
6577       }
6578 
6579       // .../InitializerMatrix
6580       {
6581          {
6582             using T1 = InitializerMatrix<int>;
6583             using T2 = InitializerMatrix<double>;
6584             using RT = DynamicMatrix<double,rowMajor>;
6585             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6586 
6587             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6588             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6589             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6590          }
6591       }
6592 
6593       // .../CompressedMatrix
6594       {
6595          {
6596             using T1 = InitializerMatrix<int>;
6597             using T2 = CompressedMatrix<double,rowMajor>;
6598             using RT = CompressedMatrix<double,rowMajor>;
6599             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6600 
6601             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6602             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6603             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6604          }
6605          {
6606             using T1 = InitializerMatrix<int>;
6607             using T2 = CompressedMatrix<double,columnMajor>;
6608             using RT = CompressedMatrix<double,columnMajor>;
6609             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6610 
6611             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6612             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6613             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6614          }
6615       }
6616 
6617       // .../IdentityMatrix
6618       {
6619          {
6620             using T1 = InitializerMatrix<int>;
6621             using T2 = IdentityMatrix<double,rowMajor>;
6622             using RT = CompressedMatrix<double,rowMajor>;
6623             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6624 
6625             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6626             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6627             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6628          }
6629          {
6630             using T1 = InitializerMatrix<int>;
6631             using T2 = IdentityMatrix<double,columnMajor>;
6632             using RT = CompressedMatrix<double,columnMajor>;
6633             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6634 
6635             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6636             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6637             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6638          }
6639       }
6640 
6641       // .../ZeroMatrix
6642       {
6643          {
6644             using T1 = InitializerMatrix<int>;
6645             using T2 = ZeroMatrix<double,rowMajor>;
6646             using RT = ZeroMatrix<double,rowMajor>;
6647             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6648 
6649             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6650             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6651             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6652          }
6653          {
6654             using T1 = InitializerMatrix<int>;
6655             using T2 = ZeroMatrix<double,columnMajor>;
6656             using RT = ZeroMatrix<double,columnMajor>;
6657             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6658 
6659             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6660             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6661             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6662          }
6663       }
6664 
6665       // .../SymmetricMatrix<DynamicMatrix> (real)
6666       {
6667          {
6668             using T1 = InitializerMatrix<int>;
6669             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
6670             using RT = DynamicMatrix<double,rowMajor>;
6671             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6672 
6673             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6674             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6675             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6676          }
6677          {
6678             using T1 = InitializerMatrix<int>;
6679             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
6680             using RT = DynamicMatrix<double,columnMajor>;
6681             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6682 
6683             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6684             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6685             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6686          }
6687       }
6688 
6689       // .../SymmetricMatrix<DynamicMatrix> (complex)
6690       {
6691          {
6692             using T1 = InitializerMatrix<int>;
6693             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
6694             using RT = DynamicMatrix<complex<int>,rowMajor>;
6695             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6696 
6697             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6698             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6699             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6700          }
6701          {
6702             using T1 = InitializerMatrix<int>;
6703             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
6704             using RT = DynamicMatrix<complex<int>,columnMajor>;
6705             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6706 
6707             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6708             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6709             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6710          }
6711       }
6712 
6713       // .../SymmetricMatrix<UniformMatrix>
6714       {
6715          {
6716             using T1 = InitializerMatrix<int>;
6717             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
6718             using RT = DynamicMatrix<double,rowMajor>;
6719             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6720 
6721             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6722             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6723             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6724          }
6725          {
6726             using T1 = InitializerMatrix<int>;
6727             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
6728             using RT = DynamicMatrix<double,columnMajor>;
6729             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6730 
6731             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6732             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6733             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6734          }
6735       }
6736 
6737       // .../SymmetricMatrix<ZeroMatrix>
6738       {
6739          {
6740             using T1 = InitializerMatrix<int>;
6741             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
6742             using RT = ZeroMatrix<double,rowMajor>;
6743             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6744 
6745             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6746             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6747             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6748          }
6749          {
6750             using T1 = InitializerMatrix<int>;
6751             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
6752             using RT = ZeroMatrix<double,columnMajor>;
6753             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6754 
6755             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6756             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6757             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6758          }
6759       }
6760 
6761       // .../HermitianMatrix<DynamicMatrix> (symmetric)
6762       {
6763          {
6764             using T1 = InitializerMatrix<int>;
6765             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
6766             using RT = DynamicMatrix<double,rowMajor>;
6767             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6768 
6769             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6770             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6771             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6772          }
6773          {
6774             using T1 = InitializerMatrix<int>;
6775             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
6776             using RT = DynamicMatrix<double,columnMajor>;
6777             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6778 
6779             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6780             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6781             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6782          }
6783       }
6784 
6785       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
6786       {
6787          {
6788             using T1 = InitializerMatrix<int>;
6789             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
6790             using RT = DynamicMatrix<complex<int>,rowMajor>;
6791             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6792 
6793             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6794             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6795             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6796          }
6797          {
6798             using T1 = InitializerMatrix<int>;
6799             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
6800             using RT = DynamicMatrix<complex<int>,columnMajor>;
6801             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6802 
6803             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6804             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6805             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6806          }
6807       }
6808 
6809       // .../LowerMatrix<DynamicMatrix>
6810       {
6811          {
6812             using T1 = InitializerMatrix<int>;
6813             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
6814             using RT = DynamicMatrix<double,rowMajor>;
6815             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6816 
6817             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6818             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6819             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6820          }
6821          {
6822             using T1 = InitializerMatrix<int>;
6823             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
6824             using RT = DynamicMatrix<double,columnMajor>;
6825             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6826 
6827             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6828             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6829             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6830          }
6831       }
6832 
6833       // .../UniLowerMatrix<DynamicMatrix>
6834       {
6835          {
6836             using T1 = InitializerMatrix<int>;
6837             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
6838             using RT = DynamicMatrix<double,rowMajor>;
6839             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6840 
6841             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6842             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6843             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6844          }
6845          {
6846             using T1 = InitializerMatrix<int>;
6847             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
6848             using RT = DynamicMatrix<double,columnMajor>;
6849             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6850 
6851             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6852             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6853             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6854          }
6855       }
6856 
6857       // .../StrictlyLowerMatrix<DynamicMatrix>
6858       {
6859          {
6860             using T1 = InitializerMatrix<int>;
6861             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
6862             using RT = DynamicMatrix<double,rowMajor>;
6863             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6864 
6865             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6866             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6867             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6868          }
6869          {
6870             using T1 = InitializerMatrix<int>;
6871             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
6872             using RT = DynamicMatrix<double,columnMajor>;
6873             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6874 
6875             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6876             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6877             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6878          }
6879       }
6880 
6881       // .../UpperMatrix<DynamicMatrix>
6882       {
6883          {
6884             using T1 = InitializerMatrix<int>;
6885             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
6886             using RT = DynamicMatrix<double,rowMajor>;
6887             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6888 
6889             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6890             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6891             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6892          }
6893          {
6894             using T1 = InitializerMatrix<int>;
6895             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
6896             using RT = DynamicMatrix<double,columnMajor>;
6897             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6898 
6899             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6900             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6901             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6902          }
6903       }
6904 
6905       // .../UniUpperMatrix<DynamicMatrix>
6906       {
6907          {
6908             using T1 = InitializerMatrix<int>;
6909             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
6910             using RT = DynamicMatrix<double,rowMajor>;
6911             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6912 
6913             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6914             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6915             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6916          }
6917          {
6918             using T1 = InitializerMatrix<int>;
6919             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
6920             using RT = DynamicMatrix<double,columnMajor>;
6921             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6922 
6923             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6924             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6925             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6926          }
6927       }
6928 
6929       // .../StrictlyUpperMatrix<DynamicMatrix>
6930       {
6931          {
6932             using T1 = InitializerMatrix<int>;
6933             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
6934             using RT = DynamicMatrix<double,rowMajor>;
6935             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6936 
6937             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6938             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6939             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6940          }
6941          {
6942             using T1 = InitializerMatrix<int>;
6943             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
6944             using RT = DynamicMatrix<double,columnMajor>;
6945             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6946 
6947             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6948             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6949             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6950          }
6951       }
6952 
6953       // .../DiagonalMatrix<DynamicMatrix>
6954       {
6955          {
6956             using T1 = InitializerMatrix<int>;
6957             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
6958             using RT = DynamicMatrix<double,rowMajor>;
6959             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6960 
6961             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6962             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6963             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6964          }
6965          {
6966             using T1 = InitializerMatrix<int>;
6967             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
6968             using RT = DynamicMatrix<double,columnMajor>;
6969             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6970 
6971             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6972             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6973             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6974          }
6975       }
6976    }
6977 
6978    // CompressedMatrix/...
6979    {
6980       // .../StaticMatrix
6981       {
6982          {
6983             using T1 = CompressedMatrix<int,rowMajor>;
6984             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
6985             using RT = CompressedMatrix<double,rowMajor>;
6986             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6987 
6988             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6989             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
6990             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
6991          }
6992          {
6993             using T1 = CompressedMatrix<int,rowMajor>;
6994             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
6995             using RT = CompressedMatrix<double,rowMajor>;
6996             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
6997 
6998             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
6999             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7000             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7001          }
7002          {
7003             using T1 = CompressedMatrix<int,columnMajor>;
7004             using T2 = StaticMatrix<double,3UL,5UL,rowMajor>;
7005             using RT = CompressedMatrix<double,columnMajor>;
7006             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7007 
7008             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7009             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7010             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7011          }
7012          {
7013             using T1 = CompressedMatrix<int,columnMajor>;
7014             using T2 = StaticMatrix<double,3UL,5UL,columnMajor>;
7015             using RT = CompressedMatrix<double,columnMajor>;
7016             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7017 
7018             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7019             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7020             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7021          }
7022       }
7023 
7024       // .../HybridMatrix
7025       {
7026          {
7027             using T1 = CompressedMatrix<int,rowMajor>;
7028             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
7029             using RT = CompressedMatrix<double,rowMajor>;
7030             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7031 
7032             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7033             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7034             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7035          }
7036          {
7037             using T1 = CompressedMatrix<int,rowMajor>;
7038             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
7039             using RT = CompressedMatrix<double,rowMajor>;
7040             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7041 
7042             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7043             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7044             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7045          }
7046          {
7047             using T1 = CompressedMatrix<int,columnMajor>;
7048             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
7049             using RT = CompressedMatrix<double,columnMajor>;
7050             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7051 
7052             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7053             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7054             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7055          }
7056          {
7057             using T1 = CompressedMatrix<int,columnMajor>;
7058             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
7059             using RT = CompressedMatrix<double,columnMajor>;
7060             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7061 
7062             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7063             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7064             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7065          }
7066       }
7067 
7068       // .../DynamicMatrix
7069       {
7070          {
7071             using T1 = CompressedMatrix<int,rowMajor>;
7072             using T2 = DynamicMatrix<double,rowMajor>;
7073             using RT = CompressedMatrix<double,rowMajor>;
7074             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7075 
7076             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7077             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7078             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7079          }
7080          {
7081             using T1 = CompressedMatrix<int,rowMajor>;
7082             using T2 = DynamicMatrix<double,columnMajor>;
7083             using RT = CompressedMatrix<double,rowMajor>;
7084             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7085 
7086             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7087             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7088             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7089          }
7090          {
7091             using T1 = CompressedMatrix<int,columnMajor>;
7092             using T2 = DynamicMatrix<double,rowMajor>;
7093             using RT = CompressedMatrix<double,columnMajor>;
7094             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7095 
7096             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7097             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7098             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7099          }
7100          {
7101             using T1 = CompressedMatrix<int,columnMajor>;
7102             using T2 = DynamicMatrix<double,columnMajor>;
7103             using RT = CompressedMatrix<double,columnMajor>;
7104             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7105 
7106             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7107             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7108             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7109          }
7110       }
7111 
7112       // .../CustomMatrix
7113       {
7114          {
7115             using T1 = CompressedMatrix<int,rowMajor>;
7116             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
7117             using RT = CompressedMatrix<double,rowMajor>;
7118             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7119 
7120             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7121             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7122             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7123          }
7124          {
7125             using T1 = CompressedMatrix<int,rowMajor>;
7126             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
7127             using RT = CompressedMatrix<double,rowMajor>;
7128             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7129 
7130             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7131             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7132             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7133          }
7134          {
7135             using T1 = CompressedMatrix<int,columnMajor>;
7136             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
7137             using RT = CompressedMatrix<double,columnMajor>;
7138             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7139 
7140             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7141             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7142             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7143          }
7144          {
7145             using T1 = CompressedMatrix<int,columnMajor>;
7146             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
7147             using RT = CompressedMatrix<double,columnMajor>;
7148             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7149 
7150             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7151             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7152             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7153          }
7154       }
7155 
7156       // .../UniformMatrix
7157       {
7158          {
7159             using T1 = CompressedMatrix<int,rowMajor>;
7160             using T2 = UniformMatrix<double,rowMajor>;
7161             using RT = CompressedMatrix<double,rowMajor>;
7162             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7163 
7164             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7165             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7166             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7167          }
7168          {
7169             using T1 = CompressedMatrix<int,rowMajor>;
7170             using T2 = UniformMatrix<double,columnMajor>;
7171             using RT = CompressedMatrix<double,rowMajor>;
7172             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7173 
7174             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7175             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7176             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7177          }
7178          {
7179             using T1 = CompressedMatrix<int,columnMajor>;
7180             using T2 = UniformMatrix<double,rowMajor>;
7181             using RT = CompressedMatrix<double,columnMajor>;
7182             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7183 
7184             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7185             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7186             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7187          }
7188          {
7189             using T1 = CompressedMatrix<int,columnMajor>;
7190             using T2 = UniformMatrix<double,columnMajor>;
7191             using RT = CompressedMatrix<double,columnMajor>;
7192             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7193 
7194             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7195             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7196             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7197          }
7198       }
7199 
7200       // .../InitializerMatrix
7201       {
7202          {
7203             using T1 = CompressedMatrix<int,rowMajor>;
7204             using T2 = InitializerMatrix<double>;
7205             using RT = CompressedMatrix<double,rowMajor>;
7206             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7207 
7208             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7209             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7210             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7211          }
7212          {
7213             using T1 = CompressedMatrix<int,columnMajor>;
7214             using T2 = InitializerMatrix<double>;
7215             using RT = CompressedMatrix<double,columnMajor>;
7216             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7217 
7218             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7219             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7220             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7221          }
7222       }
7223 
7224       // .../CompressedMatrix
7225       {
7226          {
7227             using T1 = CompressedMatrix<int,rowMajor>;
7228             using T2 = CompressedMatrix<double,rowMajor>;
7229             using RT = CompressedMatrix<double,rowMajor>;
7230             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7231 
7232             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7233             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7234             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7235          }
7236          {
7237             using T1 = CompressedMatrix<int,rowMajor>;
7238             using T2 = CompressedMatrix<double,columnMajor>;
7239             using RT = CompressedMatrix<double,columnMajor>;
7240             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7241 
7242             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7243             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7244             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7245          }
7246          {
7247             using T1 = CompressedMatrix<int,columnMajor>;
7248             using T2 = CompressedMatrix<double,rowMajor>;
7249             using RT = CompressedMatrix<double,rowMajor>;
7250             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7251 
7252             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7253             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7254             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7255          }
7256          {
7257             using T1 = CompressedMatrix<int,columnMajor>;
7258             using T2 = CompressedMatrix<double,columnMajor>;
7259             using RT = CompressedMatrix<double,columnMajor>;
7260             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7261 
7262             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7263             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7264             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7265          }
7266       }
7267 
7268       // .../IdentityMatrix
7269       {
7270          {
7271             using T1 = CompressedMatrix<int,rowMajor>;
7272             using T2 = IdentityMatrix<double,rowMajor>;
7273             using RT = CompressedMatrix<double,rowMajor>;
7274             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7275 
7276             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7277             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7278             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7279          }
7280          {
7281             using T1 = CompressedMatrix<int,rowMajor>;
7282             using T2 = IdentityMatrix<double,columnMajor>;
7283             using RT = CompressedMatrix<double,columnMajor>;
7284             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7285 
7286             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7287             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7288             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7289          }
7290          {
7291             using T1 = CompressedMatrix<int,columnMajor>;
7292             using T2 = IdentityMatrix<double,rowMajor>;
7293             using RT = CompressedMatrix<double,rowMajor>;
7294             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7295 
7296             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7297             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7298             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7299          }
7300          {
7301             using T1 = CompressedMatrix<int,columnMajor>;
7302             using T2 = IdentityMatrix<double,columnMajor>;
7303             using RT = CompressedMatrix<double,columnMajor>;
7304             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7305 
7306             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7307             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7308             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7309          }
7310       }
7311 
7312       // .../ZeroMatrix
7313       {
7314          {
7315             using T1 = CompressedMatrix<int,rowMajor>;
7316             using T2 = ZeroMatrix<double,rowMajor>;
7317             using RT = ZeroMatrix<double,rowMajor>;
7318             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7319 
7320             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7321             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7322             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7323          }
7324          {
7325             using T1 = CompressedMatrix<int,rowMajor>;
7326             using T2 = ZeroMatrix<double,columnMajor>;
7327             using RT = ZeroMatrix<double,columnMajor>;
7328             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7329 
7330             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7331             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7332             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7333          }
7334          {
7335             using T1 = CompressedMatrix<int,columnMajor>;
7336             using T2 = ZeroMatrix<double,rowMajor>;
7337             using RT = ZeroMatrix<double,rowMajor>;
7338             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7339 
7340             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7341             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7342             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7343          }
7344          {
7345             using T1 = CompressedMatrix<int,columnMajor>;
7346             using T2 = ZeroMatrix<double,columnMajor>;
7347             using RT = ZeroMatrix<double,columnMajor>;
7348             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7349 
7350             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7351             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7352             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7353          }
7354       }
7355 
7356       // .../SymmetricMatrix<DynamicMatrix> (real)
7357       {
7358          {
7359             using T1 = CompressedMatrix<int,rowMajor>;
7360             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
7361             using RT = CompressedMatrix<double,rowMajor>;
7362             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7363 
7364             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7365             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7366             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7367          }
7368          {
7369             using T1 = CompressedMatrix<int,rowMajor>;
7370             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
7371             using RT = CompressedMatrix<double,rowMajor>;
7372             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7373 
7374             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7375             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7376             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7377          }
7378          {
7379             using T1 = CompressedMatrix<int,columnMajor>;
7380             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
7381             using RT = CompressedMatrix<double,columnMajor>;
7382             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7383 
7384             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7385             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7386             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7387          }
7388          {
7389             using T1 = CompressedMatrix<int,columnMajor>;
7390             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
7391             using RT = CompressedMatrix<double,columnMajor>;
7392             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7393 
7394             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7395             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7396             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7397          }
7398       }
7399 
7400       // .../SymmetricMatrix<DynamicMatrix> (complex)
7401       {
7402          {
7403             using T1 = CompressedMatrix<int,rowMajor>;
7404             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
7405             using RT = CompressedMatrix<complex<int>,rowMajor>;
7406             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7407 
7408             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7409             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7410             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7411          }
7412          {
7413             using T1 = CompressedMatrix<int,rowMajor>;
7414             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
7415             using RT = CompressedMatrix<complex<int>,rowMajor>;
7416             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7417 
7418             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7419             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7420             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7421          }
7422          {
7423             using T1 = CompressedMatrix<int,columnMajor>;
7424             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
7425             using RT = CompressedMatrix<complex<int>,columnMajor>;
7426             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7427 
7428             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7429             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7430             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7431          }
7432          {
7433             using T1 = CompressedMatrix<int,columnMajor>;
7434             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
7435             using RT = CompressedMatrix<complex<int>,columnMajor>;
7436             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7437 
7438             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7439             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7440             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7441          }
7442       }
7443 
7444       // .../SymmetricMatrix<UniformMatrix>
7445       {
7446          {
7447             using T1 = CompressedMatrix<int,rowMajor>;
7448             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
7449             using RT = CompressedMatrix<double,rowMajor>;
7450             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7451 
7452             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7453             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7454             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7455          }
7456          {
7457             using T1 = CompressedMatrix<int,rowMajor>;
7458             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
7459             using RT = CompressedMatrix<double,rowMajor>;
7460             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7461 
7462             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7463             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7464             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7465          }
7466          {
7467             using T1 = CompressedMatrix<int,columnMajor>;
7468             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
7469             using RT = CompressedMatrix<double,columnMajor>;
7470             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7471 
7472             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7473             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7474             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7475          }
7476          {
7477             using T1 = CompressedMatrix<int,columnMajor>;
7478             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
7479             using RT = CompressedMatrix<double,columnMajor>;
7480             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7481 
7482             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7483             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7484             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7485          }
7486       }
7487 
7488       // .../SymmetricMatrix<ZeroMatrix>
7489       {
7490          {
7491             using T1 = CompressedMatrix<int,rowMajor>;
7492             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
7493             using RT = ZeroMatrix<double,rowMajor>;
7494             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7495 
7496             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7497             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7498             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7499          }
7500          {
7501             using T1 = CompressedMatrix<int,rowMajor>;
7502             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
7503             using RT = ZeroMatrix<double,columnMajor>;
7504             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7505 
7506             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7507             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7508             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7509          }
7510          {
7511             using T1 = CompressedMatrix<int,columnMajor>;
7512             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
7513             using RT = ZeroMatrix<double,rowMajor>;
7514             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7515 
7516             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7517             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7518             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7519          }
7520          {
7521             using T1 = CompressedMatrix<int,columnMajor>;
7522             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
7523             using RT = ZeroMatrix<double,columnMajor>;
7524             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7525 
7526             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7527             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7528             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7529          }
7530       }
7531 
7532       // .../HermitianMatrix<DynamicMatrix> (symmetric)
7533       {
7534          {
7535             using T1 = CompressedMatrix<int,rowMajor>;
7536             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
7537             using RT = CompressedMatrix<double,rowMajor>;
7538             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7539 
7540             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7541             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7542             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7543          }
7544          {
7545             using T1 = CompressedMatrix<int,rowMajor>;
7546             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
7547             using RT = CompressedMatrix<double,rowMajor>;
7548             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7549 
7550             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7551             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7552             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7553          }
7554          {
7555             using T1 = CompressedMatrix<int,columnMajor>;
7556             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
7557             using RT = CompressedMatrix<double,columnMajor>;
7558             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7559 
7560             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7561             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7562             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7563          }
7564          {
7565             using T1 = CompressedMatrix<int,columnMajor>;
7566             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
7567             using RT = CompressedMatrix<double,columnMajor>;
7568             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7569 
7570             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7571             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7572             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7573          }
7574       }
7575 
7576       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
7577       {
7578          {
7579             using T1 = CompressedMatrix<int,rowMajor>;
7580             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
7581             using RT = CompressedMatrix<complex<int>,rowMajor>;
7582             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7583 
7584             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7585             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7586             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7587          }
7588          {
7589             using T1 = CompressedMatrix<int,rowMajor>;
7590             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
7591             using RT = CompressedMatrix<complex<int>,rowMajor>;
7592             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7593 
7594             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7595             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7596             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7597          }
7598          {
7599             using T1 = CompressedMatrix<int,columnMajor>;
7600             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
7601             using RT = CompressedMatrix<complex<int>,columnMajor>;
7602             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7603 
7604             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7605             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7606             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7607          }
7608          {
7609             using T1 = CompressedMatrix<int,columnMajor>;
7610             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
7611             using RT = CompressedMatrix<complex<int>,columnMajor>;
7612             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7613 
7614             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7615             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7616             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7617          }
7618       }
7619 
7620       // .../LowerMatrix<DynamicMatrix>
7621       {
7622          {
7623             using T1 = CompressedMatrix<int,rowMajor>;
7624             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
7625             using RT = CompressedMatrix<double,rowMajor>;
7626             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7627 
7628             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7629             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7630             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7631          }
7632          {
7633             using T1 = CompressedMatrix<int,rowMajor>;
7634             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
7635             using RT = CompressedMatrix<double,rowMajor>;
7636             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7637 
7638             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7639             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7640             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7641          }
7642          {
7643             using T1 = CompressedMatrix<int,columnMajor>;
7644             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
7645             using RT = CompressedMatrix<double,columnMajor>;
7646             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7647 
7648             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7649             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7650             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7651          }
7652          {
7653             using T1 = CompressedMatrix<int,columnMajor>;
7654             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
7655             using RT = CompressedMatrix<double,columnMajor>;
7656             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7657 
7658             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7659             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7660             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7661          }
7662       }
7663 
7664       // .../UniLowerMatrix<DynamicMatrix>
7665       {
7666          {
7667             using T1 = CompressedMatrix<int,rowMajor>;
7668             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
7669             using RT = CompressedMatrix<double,rowMajor>;
7670             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7671 
7672             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7673             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7674             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7675          }
7676          {
7677             using T1 = CompressedMatrix<int,rowMajor>;
7678             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
7679             using RT = CompressedMatrix<double,rowMajor>;
7680             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7681 
7682             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7683             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7684             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7685          }
7686          {
7687             using T1 = CompressedMatrix<int,columnMajor>;
7688             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
7689             using RT = CompressedMatrix<double,columnMajor>;
7690             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7691 
7692             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7693             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7694             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7695          }
7696          {
7697             using T1 = CompressedMatrix<int,columnMajor>;
7698             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
7699             using RT = CompressedMatrix<double,columnMajor>;
7700             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7701 
7702             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7703             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7704             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7705          }
7706       }
7707 
7708       // .../StrictlyLowerMatrix<DynamicMatrix>
7709       {
7710          {
7711             using T1 = CompressedMatrix<int,rowMajor>;
7712             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
7713             using RT = CompressedMatrix<double,rowMajor>;
7714             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7715 
7716             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7717             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7718             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7719          }
7720          {
7721             using T1 = CompressedMatrix<int,rowMajor>;
7722             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
7723             using RT = CompressedMatrix<double,rowMajor>;
7724             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7725 
7726             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7727             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7728             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7729          }
7730          {
7731             using T1 = CompressedMatrix<int,columnMajor>;
7732             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
7733             using RT = CompressedMatrix<double,columnMajor>;
7734             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7735 
7736             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7737             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7738             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7739          }
7740          {
7741             using T1 = CompressedMatrix<int,columnMajor>;
7742             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
7743             using RT = CompressedMatrix<double,columnMajor>;
7744             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7745 
7746             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7747             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7748             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7749          }
7750       }
7751 
7752       // .../UpperMatrix<DynamicMatrix>
7753       {
7754          {
7755             using T1 = CompressedMatrix<int,rowMajor>;
7756             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
7757             using RT = CompressedMatrix<double,rowMajor>;
7758             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7759 
7760             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7761             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7762             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7763          }
7764          {
7765             using T1 = CompressedMatrix<int,rowMajor>;
7766             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
7767             using RT = CompressedMatrix<double,rowMajor>;
7768             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7769 
7770             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7771             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7772             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7773          }
7774          {
7775             using T1 = CompressedMatrix<int,columnMajor>;
7776             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
7777             using RT = CompressedMatrix<double,columnMajor>;
7778             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7779 
7780             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7781             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7782             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7783          }
7784          {
7785             using T1 = CompressedMatrix<int,columnMajor>;
7786             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
7787             using RT = CompressedMatrix<double,columnMajor>;
7788             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7789 
7790             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7791             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7792             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7793          }
7794       }
7795 
7796       // .../UniUpperMatrix<DynamicMatrix>
7797       {
7798          {
7799             using T1 = CompressedMatrix<int,rowMajor>;
7800             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
7801             using RT = CompressedMatrix<double,rowMajor>;
7802             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7803 
7804             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7805             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7806             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7807          }
7808          {
7809             using T1 = CompressedMatrix<int,rowMajor>;
7810             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
7811             using RT = CompressedMatrix<double,rowMajor>;
7812             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7813 
7814             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7815             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7816             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7817          }
7818          {
7819             using T1 = CompressedMatrix<int,columnMajor>;
7820             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
7821             using RT = CompressedMatrix<double,columnMajor>;
7822             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7823 
7824             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7825             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7826             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7827          }
7828          {
7829             using T1 = CompressedMatrix<int,columnMajor>;
7830             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
7831             using RT = CompressedMatrix<double,columnMajor>;
7832             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7833 
7834             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7835             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7836             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7837          }
7838       }
7839 
7840       // .../StrictlyUpperMatrix<DynamicMatrix>
7841       {
7842          {
7843             using T1 = CompressedMatrix<int,rowMajor>;
7844             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
7845             using RT = CompressedMatrix<double,rowMajor>;
7846             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7847 
7848             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7849             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7850             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7851          }
7852          {
7853             using T1 = CompressedMatrix<int,rowMajor>;
7854             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
7855             using RT = CompressedMatrix<double,rowMajor>;
7856             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7857 
7858             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7859             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7860             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7861          }
7862          {
7863             using T1 = CompressedMatrix<int,columnMajor>;
7864             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
7865             using RT = CompressedMatrix<double,columnMajor>;
7866             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7867 
7868             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7869             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7870             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7871          }
7872          {
7873             using T1 = CompressedMatrix<int,columnMajor>;
7874             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
7875             using RT = CompressedMatrix<double,columnMajor>;
7876             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7877 
7878             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7879             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7880             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7881          }
7882       }
7883 
7884       // .../DiagonalMatrix<DynamicMatrix>
7885       {
7886          {
7887             using T1 = CompressedMatrix<int,rowMajor>;
7888             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
7889             using RT = CompressedMatrix<double,rowMajor>;
7890             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7891 
7892             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7893             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7894             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7895          }
7896          {
7897             using T1 = CompressedMatrix<int,rowMajor>;
7898             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
7899             using RT = CompressedMatrix<double,rowMajor>;
7900             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7901 
7902             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7903             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7904             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7905          }
7906          {
7907             using T1 = CompressedMatrix<int,columnMajor>;
7908             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
7909             using RT = CompressedMatrix<double,columnMajor>;
7910             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7911 
7912             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7913             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7914             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7915          }
7916          {
7917             using T1 = CompressedMatrix<int,columnMajor>;
7918             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
7919             using RT = CompressedMatrix<double,columnMajor>;
7920             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7921 
7922             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7923             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7924             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7925          }
7926       }
7927    }
7928 
7929    // IdentityMatrix/...
7930    {
7931       // .../StaticMatrix
7932       {
7933          {
7934             using T1 = IdentityMatrix<int,rowMajor>;
7935             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
7936             using RT = CompressedMatrix<double,rowMajor>;
7937             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7938 
7939             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7940             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7941             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7942          }
7943          {
7944             using T1 = IdentityMatrix<int,rowMajor>;
7945             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
7946             using RT = CompressedMatrix<double,rowMajor>;
7947             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7948 
7949             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7950             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7951             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7952          }
7953          {
7954             using T1 = IdentityMatrix<int,columnMajor>;
7955             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
7956             using RT = CompressedMatrix<double,columnMajor>;
7957             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7958 
7959             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7960             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7961             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7962          }
7963          {
7964             using T1 = IdentityMatrix<int,columnMajor>;
7965             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
7966             using RT = CompressedMatrix<double,columnMajor>;
7967             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7968 
7969             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7970             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7971             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7972          }
7973       }
7974 
7975       // .../HybridMatrix
7976       {
7977          {
7978             using T1 = IdentityMatrix<int,rowMajor>;
7979             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
7980             using RT = CompressedMatrix<double,rowMajor>;
7981             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7982 
7983             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7984             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7985             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7986          }
7987          {
7988             using T1 = IdentityMatrix<int,rowMajor>;
7989             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
7990             using RT = CompressedMatrix<double,rowMajor>;
7991             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
7992 
7993             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
7994             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
7995             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
7996          }
7997          {
7998             using T1 = IdentityMatrix<int,columnMajor>;
7999             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
8000             using RT = CompressedMatrix<double,columnMajor>;
8001             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8002 
8003             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8004             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8005             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8006          }
8007          {
8008             using T1 = IdentityMatrix<int,columnMajor>;
8009             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
8010             using RT = CompressedMatrix<double,columnMajor>;
8011             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8012 
8013             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8014             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8015             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8016          }
8017       }
8018 
8019       // .../DynamicMatrix
8020       {
8021          {
8022             using T1 = IdentityMatrix<int,rowMajor>;
8023             using T2 = DynamicMatrix<double,rowMajor>;
8024             using RT = CompressedMatrix<double,rowMajor>;
8025             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8026 
8027             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8028             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8029             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8030          }
8031          {
8032             using T1 = IdentityMatrix<int,rowMajor>;
8033             using T2 = DynamicMatrix<double,columnMajor>;
8034             using RT = CompressedMatrix<double,rowMajor>;
8035             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8036 
8037             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8038             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8039             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8040          }
8041          {
8042             using T1 = IdentityMatrix<int,columnMajor>;
8043             using T2 = DynamicMatrix<double,rowMajor>;
8044             using RT = CompressedMatrix<double,columnMajor>;
8045             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8046 
8047             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8048             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8049             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8050          }
8051          {
8052             using T1 = IdentityMatrix<int,columnMajor>;
8053             using T2 = DynamicMatrix<double,columnMajor>;
8054             using RT = CompressedMatrix<double,columnMajor>;
8055             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8056 
8057             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8058             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8059             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8060          }
8061       }
8062 
8063       // .../CustomMatrix
8064       {
8065          {
8066             using T1 = IdentityMatrix<int,rowMajor>;
8067             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
8068             using RT = CompressedMatrix<double,rowMajor>;
8069             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8070 
8071             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8072             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8073             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8074          }
8075          {
8076             using T1 = IdentityMatrix<int,rowMajor>;
8077             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
8078             using RT = CompressedMatrix<double,rowMajor>;
8079             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8080 
8081             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8082             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8083             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8084          }
8085          {
8086             using T1 = IdentityMatrix<int,columnMajor>;
8087             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
8088             using RT = CompressedMatrix<double,columnMajor>;
8089             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8090 
8091             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8092             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8093             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8094          }
8095          {
8096             using T1 = IdentityMatrix<int,columnMajor>;
8097             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
8098             using RT = CompressedMatrix<double,columnMajor>;
8099             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8100 
8101             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8102             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8103             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8104          }
8105       }
8106 
8107       // .../UniformMatrix
8108       {
8109          {
8110             using T1 = IdentityMatrix<int,rowMajor>;
8111             using T2 = UniformMatrix<double,rowMajor>;
8112             using RT = CompressedMatrix<double,rowMajor>;
8113             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8114 
8115             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8116             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8117             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8118          }
8119          {
8120             using T1 = IdentityMatrix<int,rowMajor>;
8121             using T2 = UniformMatrix<double,columnMajor>;
8122             using RT = CompressedMatrix<double,rowMajor>;
8123             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8124 
8125             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8126             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8127             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8128          }
8129          {
8130             using T1 = IdentityMatrix<int,columnMajor>;
8131             using T2 = UniformMatrix<double,rowMajor>;
8132             using RT = CompressedMatrix<double,columnMajor>;
8133             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8134 
8135             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8136             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8137             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8138          }
8139          {
8140             using T1 = IdentityMatrix<int,columnMajor>;
8141             using T2 = UniformMatrix<double,columnMajor>;
8142             using RT = CompressedMatrix<double,columnMajor>;
8143             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8144 
8145             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8146             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8147             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8148          }
8149       }
8150 
8151       // .../InitializerMatrix
8152       {
8153          {
8154             using T1 = IdentityMatrix<int,rowMajor>;
8155             using T2 = InitializerMatrix<double>;
8156             using RT = CompressedMatrix<double,rowMajor>;
8157             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8158 
8159             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8160             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8161             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8162          }
8163          {
8164             using T1 = IdentityMatrix<int,columnMajor>;
8165             using T2 = InitializerMatrix<double>;
8166             using RT = CompressedMatrix<double,columnMajor>;
8167             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8168 
8169             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8170             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8171             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8172          }
8173       }
8174 
8175       // .../CompressedMatrix
8176       {
8177          {
8178             using T1 = IdentityMatrix<int,rowMajor>;
8179             using T2 = CompressedMatrix<double,rowMajor>;
8180             using RT = CompressedMatrix<double,rowMajor>;
8181             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8182 
8183             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8184             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8185             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8186          }
8187          {
8188             using T1 = IdentityMatrix<int,rowMajor>;
8189             using T2 = CompressedMatrix<double,columnMajor>;
8190             using RT = CompressedMatrix<double,columnMajor>;
8191             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8192 
8193             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8194             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8195             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8196          }
8197          {
8198             using T1 = IdentityMatrix<int,columnMajor>;
8199             using T2 = CompressedMatrix<double,rowMajor>;
8200             using RT = CompressedMatrix<double,rowMajor>;
8201             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8202 
8203             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8204             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8205             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8206          }
8207          {
8208             using T1 = IdentityMatrix<int,columnMajor>;
8209             using T2 = CompressedMatrix<double,columnMajor>;
8210             using RT = CompressedMatrix<double,columnMajor>;
8211             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8212 
8213             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8214             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8215             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8216          }
8217       }
8218 
8219       // .../IdentityMatrix
8220       {
8221          {
8222             using T1 = IdentityMatrix<int,rowMajor>;
8223             using T2 = IdentityMatrix<double,rowMajor>;
8224             using RT = IdentityMatrix<double,rowMajor>;
8225             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8226 
8227             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8228             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8229             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8230          }
8231          {
8232             using T1 = IdentityMatrix<int,rowMajor>;
8233             using T2 = IdentityMatrix<double,columnMajor>;
8234             using RT = IdentityMatrix<double,columnMajor>;
8235             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8236 
8237             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8238             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8239             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8240          }
8241          {
8242             using T1 = IdentityMatrix<int,columnMajor>;
8243             using T2 = IdentityMatrix<double,rowMajor>;
8244             using RT = IdentityMatrix<double,rowMajor>;
8245             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8246 
8247             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8248             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8249             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8250          }
8251          {
8252             using T1 = IdentityMatrix<int,columnMajor>;
8253             using T2 = IdentityMatrix<double,columnMajor>;
8254             using RT = IdentityMatrix<double,columnMajor>;
8255             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8256 
8257             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8258             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8259             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8260          }
8261       }
8262 
8263       // .../ZeroMatrix
8264       {
8265          {
8266             using T1 = IdentityMatrix<int,rowMajor>;
8267             using T2 = ZeroMatrix<double,rowMajor>;
8268             using RT = ZeroMatrix<double,rowMajor>;
8269             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8270 
8271             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8272             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8273             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8274          }
8275          {
8276             using T1 = IdentityMatrix<int,rowMajor>;
8277             using T2 = ZeroMatrix<double,columnMajor>;
8278             using RT = ZeroMatrix<double,columnMajor>;
8279             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8280 
8281             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8282             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8283             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8284          }
8285          {
8286             using T1 = IdentityMatrix<int,columnMajor>;
8287             using T2 = ZeroMatrix<double,rowMajor>;
8288             using RT = ZeroMatrix<double,rowMajor>;
8289             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8290 
8291             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8292             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8293             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8294          }
8295          {
8296             using T1 = IdentityMatrix<int,columnMajor>;
8297             using T2 = ZeroMatrix<double,columnMajor>;
8298             using RT = ZeroMatrix<double,columnMajor>;
8299             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8300 
8301             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8302             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8303             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8304          }
8305       }
8306 
8307       // .../SymmetricMatrix<DynamicMatrix> (real)
8308       {
8309          {
8310             using T1 = IdentityMatrix<int,rowMajor>;
8311             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
8312             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
8313             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8314 
8315             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8316             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8317             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8318          }
8319          {
8320             using T1 = IdentityMatrix<int,rowMajor>;
8321             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
8322             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
8323             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8324 
8325             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8326             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8327             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8328          }
8329          {
8330             using T1 = IdentityMatrix<int,columnMajor>;
8331             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
8332             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
8333             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8334 
8335             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8336             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8337             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8338          }
8339          {
8340             using T1 = IdentityMatrix<int,columnMajor>;
8341             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
8342             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
8343             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8344 
8345             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8346             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8347             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8348          }
8349       }
8350 
8351       // .../SymmetricMatrix<DynamicMatrix> (complex)
8352       {
8353          {
8354             using T1 = IdentityMatrix<int,rowMajor>;
8355             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
8356             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,rowMajor> >;
8357             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8358 
8359             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8360             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8361             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8362          }
8363          {
8364             using T1 = IdentityMatrix<int,rowMajor>;
8365             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
8366             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,rowMajor> >;
8367             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8368 
8369             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8370             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8371             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8372          }
8373          {
8374             using T1 = IdentityMatrix<int,columnMajor>;
8375             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
8376             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,columnMajor> >;
8377             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8378 
8379             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8380             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8381             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8382          }
8383          {
8384             using T1 = IdentityMatrix<int,columnMajor>;
8385             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
8386             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,columnMajor> >;
8387             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8388 
8389             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8390             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8391             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8392          }
8393       }
8394 
8395       // .../SymmetricMatrix<UniformMatrix>
8396       {
8397          {
8398             using T1 = IdentityMatrix<int,rowMajor>;
8399             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
8400             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
8401             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8402 
8403             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8404             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8405             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8406          }
8407          {
8408             using T1 = IdentityMatrix<int,rowMajor>;
8409             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
8410             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
8411             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8412 
8413             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8414             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8415             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8416          }
8417          {
8418             using T1 = IdentityMatrix<int,columnMajor>;
8419             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
8420             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
8421             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8422 
8423             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8424             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8425             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8426          }
8427          {
8428             using T1 = IdentityMatrix<int,columnMajor>;
8429             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
8430             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
8431             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8432 
8433             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8434             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8435             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8436          }
8437       }
8438 
8439       // .../SymmetricMatrix<ZeroMatrix>
8440       {
8441          {
8442             using T1 = IdentityMatrix<int,rowMajor>;
8443             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
8444             using RT = ZeroMatrix<double,rowMajor>;
8445             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8446 
8447             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8448             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8449             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8450          }
8451          {
8452             using T1 = IdentityMatrix<int,rowMajor>;
8453             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
8454             using RT = ZeroMatrix<double,columnMajor>;
8455             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8456 
8457             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8458             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8459             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8460          }
8461          {
8462             using T1 = IdentityMatrix<int,columnMajor>;
8463             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
8464             using RT = ZeroMatrix<double,rowMajor>;
8465             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8466 
8467             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8468             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8469             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8470          }
8471          {
8472             using T1 = IdentityMatrix<int,columnMajor>;
8473             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
8474             using RT = ZeroMatrix<double,columnMajor>;
8475             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8476 
8477             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8478             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8479             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8480          }
8481       }
8482 
8483       // .../HermitianMatrix<DynamicMatrix> (symmetric)
8484       {
8485          {
8486             using T1 = IdentityMatrix<int,rowMajor>;
8487             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
8488             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
8489             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8490 
8491             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8492             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8493             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8494          }
8495          {
8496             using T1 = IdentityMatrix<int,rowMajor>;
8497             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
8498             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
8499             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8500 
8501             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8502             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8503             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8504          }
8505          {
8506             using T1 = IdentityMatrix<int,columnMajor>;
8507             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
8508             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
8509             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8510 
8511             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8512             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8513             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8514          }
8515          {
8516             using T1 = IdentityMatrix<int,columnMajor>;
8517             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
8518             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
8519             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8520 
8521             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8522             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8523             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8524          }
8525       }
8526 
8527       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
8528       {
8529          {
8530             using T1 = IdentityMatrix<int,rowMajor>;
8531             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
8532             using RT = HermitianMatrix< CompressedMatrix<complex<int>,rowMajor> >;
8533             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8534 
8535             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8536             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8537             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8538          }
8539          {
8540             using T1 = IdentityMatrix<int,rowMajor>;
8541             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
8542             using RT = HermitianMatrix< CompressedMatrix<complex<int>,rowMajor> >;
8543             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8544 
8545             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8546             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8547             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8548          }
8549          {
8550             using T1 = IdentityMatrix<int,columnMajor>;
8551             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
8552             using RT = HermitianMatrix< CompressedMatrix<complex<int>,columnMajor> >;
8553             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8554 
8555             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8556             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8557             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8558          }
8559          {
8560             using T1 = IdentityMatrix<int,columnMajor>;
8561             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
8562             using RT = HermitianMatrix< CompressedMatrix<complex<int>,columnMajor> >;
8563             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8564 
8565             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8566             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8567             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8568          }
8569       }
8570 
8571       // .../LowerMatrix<DynamicMatrix>
8572       {
8573          {
8574             using T1 = IdentityMatrix<int,rowMajor>;
8575             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
8576             using RT = LowerMatrix< CompressedMatrix<double,rowMajor> >;
8577             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8578 
8579             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8580             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8581             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8582          }
8583          {
8584             using T1 = IdentityMatrix<int,rowMajor>;
8585             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
8586             using RT = LowerMatrix< CompressedMatrix<double,rowMajor> >;
8587             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8588 
8589             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8590             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8591             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8592          }
8593          {
8594             using T1 = IdentityMatrix<int,columnMajor>;
8595             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
8596             using RT = LowerMatrix< CompressedMatrix<double,columnMajor> >;
8597             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8598 
8599             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8600             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8601             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8602          }
8603          {
8604             using T1 = IdentityMatrix<int,columnMajor>;
8605             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
8606             using RT = LowerMatrix< CompressedMatrix<double,columnMajor> >;
8607             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8608 
8609             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8610             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8611             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8612          }
8613       }
8614 
8615       // .../UniLowerMatrix<DynamicMatrix>
8616       {
8617          {
8618             using T1 = IdentityMatrix<int,rowMajor>;
8619             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
8620             using RT = UniLowerMatrix< CompressedMatrix<double,rowMajor> >;
8621             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8622 
8623             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8624             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8625             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8626          }
8627          {
8628             using T1 = IdentityMatrix<int,rowMajor>;
8629             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
8630             using RT = UniLowerMatrix< CompressedMatrix<double,rowMajor> >;
8631             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8632 
8633             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8634             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8635             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8636          }
8637          {
8638             using T1 = IdentityMatrix<int,columnMajor>;
8639             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
8640             using RT = UniLowerMatrix< CompressedMatrix<double,columnMajor> >;
8641             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8642 
8643             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8644             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8645             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8646          }
8647          {
8648             using T1 = IdentityMatrix<int,columnMajor>;
8649             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
8650             using RT = UniLowerMatrix< CompressedMatrix<double,columnMajor> >;
8651             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8652 
8653             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8654             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8655             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8656          }
8657       }
8658 
8659       // .../StrictlyLowerMatrix<DynamicMatrix>
8660       {
8661          {
8662             using T1 = IdentityMatrix<int,rowMajor>;
8663             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
8664             using RT = StrictlyLowerMatrix< CompressedMatrix<double,rowMajor> >;
8665             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8666 
8667             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8668             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8669             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8670          }
8671          {
8672             using T1 = IdentityMatrix<int,rowMajor>;
8673             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
8674             using RT = StrictlyLowerMatrix< CompressedMatrix<double,rowMajor> >;
8675             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8676 
8677             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8678             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8679             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8680          }
8681          {
8682             using T1 = IdentityMatrix<int,columnMajor>;
8683             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
8684             using RT = StrictlyLowerMatrix< CompressedMatrix<double,columnMajor> >;
8685             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8686 
8687             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8688             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8689             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8690          }
8691          {
8692             using T1 = IdentityMatrix<int,columnMajor>;
8693             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
8694             using RT = StrictlyLowerMatrix< CompressedMatrix<double,columnMajor> >;
8695             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8696 
8697             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8698             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8699             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8700          }
8701       }
8702 
8703       // .../UpperMatrix<DynamicMatrix>
8704       {
8705          {
8706             using T1 = IdentityMatrix<int,rowMajor>;
8707             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
8708             using RT = UpperMatrix< CompressedMatrix<double,rowMajor> >;
8709             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8710 
8711             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8712             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8713             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8714          }
8715          {
8716             using T1 = IdentityMatrix<int,rowMajor>;
8717             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
8718             using RT = UpperMatrix< CompressedMatrix<double,rowMajor> >;
8719             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8720 
8721             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8722             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8723             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8724          }
8725          {
8726             using T1 = IdentityMatrix<int,columnMajor>;
8727             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
8728             using RT = UpperMatrix< CompressedMatrix<double,columnMajor> >;
8729             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8730 
8731             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8732             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8733             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8734          }
8735          {
8736             using T1 = IdentityMatrix<int,columnMajor>;
8737             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
8738             using RT = UpperMatrix< CompressedMatrix<double,columnMajor> >;
8739             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8740 
8741             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8742             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8743             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8744          }
8745       }
8746 
8747       // .../UniUpperMatrix<DynamicMatrix>
8748       {
8749          {
8750             using T1 = IdentityMatrix<int,rowMajor>;
8751             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
8752             using RT = UniUpperMatrix< CompressedMatrix<double,rowMajor> >;
8753             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8754 
8755             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8756             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8757             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8758          }
8759          {
8760             using T1 = IdentityMatrix<int,rowMajor>;
8761             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
8762             using RT = UniUpperMatrix< CompressedMatrix<double,rowMajor> >;
8763             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8764 
8765             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8766             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8767             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8768          }
8769          {
8770             using T1 = IdentityMatrix<int,columnMajor>;
8771             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
8772             using RT = UniUpperMatrix< CompressedMatrix<double,columnMajor> >;
8773             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8774 
8775             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8776             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8777             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8778          }
8779          {
8780             using T1 = IdentityMatrix<int,columnMajor>;
8781             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
8782             using RT = UniUpperMatrix< CompressedMatrix<double,columnMajor> >;
8783             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8784 
8785             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8786             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8787             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8788          }
8789       }
8790 
8791       // .../StrictlyUpperMatrix<DynamicMatrix>
8792       {
8793          {
8794             using T1 = IdentityMatrix<int,rowMajor>;
8795             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
8796             using RT = StrictlyUpperMatrix< CompressedMatrix<double,rowMajor> >;
8797             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8798 
8799             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8800             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8801             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8802          }
8803          {
8804             using T1 = IdentityMatrix<int,rowMajor>;
8805             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
8806             using RT = StrictlyUpperMatrix< CompressedMatrix<double,rowMajor> >;
8807             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8808 
8809             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8810             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8811             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8812          }
8813          {
8814             using T1 = IdentityMatrix<int,columnMajor>;
8815             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
8816             using RT = StrictlyUpperMatrix< CompressedMatrix<double,columnMajor> >;
8817             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8818 
8819             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8820             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8821             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8822          }
8823          {
8824             using T1 = IdentityMatrix<int,columnMajor>;
8825             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
8826             using RT = StrictlyUpperMatrix< CompressedMatrix<double,columnMajor> >;
8827             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8828 
8829             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8830             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8831             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8832          }
8833       }
8834 
8835       // .../DiagonalMatrix<DynamicMatrix>
8836       {
8837          {
8838             using T1 = IdentityMatrix<int,rowMajor>;
8839             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
8840             using RT = DiagonalMatrix< CompressedMatrix<double,rowMajor> >;
8841             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8842 
8843             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8844             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8845             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8846          }
8847          {
8848             using T1 = IdentityMatrix<int,rowMajor>;
8849             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
8850             using RT = DiagonalMatrix< CompressedMatrix<double,rowMajor> >;
8851             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8852 
8853             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8854             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8855             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8856          }
8857          {
8858             using T1 = IdentityMatrix<int,columnMajor>;
8859             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
8860             using RT = DiagonalMatrix< CompressedMatrix<double,columnMajor> >;
8861             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8862 
8863             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8864             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8865             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8866          }
8867          {
8868             using T1 = IdentityMatrix<int,columnMajor>;
8869             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
8870             using RT = DiagonalMatrix< CompressedMatrix<double,columnMajor> >;
8871             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8872 
8873             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8874             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8875             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8876          }
8877       }
8878    }
8879 
8880    // ZeroMatrix/...
8881    {
8882       // .../StaticMatrix
8883       {
8884          {
8885             using T1 = ZeroMatrix<int,rowMajor>;
8886             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
8887             using RT = ZeroMatrix<double,rowMajor>;
8888             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8889 
8890             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8891             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8892             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8893          }
8894          {
8895             using T1 = ZeroMatrix<int,rowMajor>;
8896             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
8897             using RT = ZeroMatrix<double,rowMajor>;
8898             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8899 
8900             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8901             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8902             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8903          }
8904          {
8905             using T1 = ZeroMatrix<int,columnMajor>;
8906             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
8907             using RT = ZeroMatrix<double,columnMajor>;
8908             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8909 
8910             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8911             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8912             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8913          }
8914          {
8915             using T1 = ZeroMatrix<int,columnMajor>;
8916             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
8917             using RT = ZeroMatrix<double,columnMajor>;
8918             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8919 
8920             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8921             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8922             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8923          }
8924       }
8925 
8926       // .../HybridMatrix
8927       {
8928          {
8929             using T1 = ZeroMatrix<int,rowMajor>;
8930             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
8931             using RT = ZeroMatrix<double,rowMajor>;
8932             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8933 
8934             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8935             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8936             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8937          }
8938          {
8939             using T1 = ZeroMatrix<int,rowMajor>;
8940             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
8941             using RT = ZeroMatrix<double,rowMajor>;
8942             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8943 
8944             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8945             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8946             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8947          }
8948          {
8949             using T1 = ZeroMatrix<int,columnMajor>;
8950             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
8951             using RT = ZeroMatrix<double,columnMajor>;
8952             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8953 
8954             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8955             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8956             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8957          }
8958          {
8959             using T1 = ZeroMatrix<int,columnMajor>;
8960             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
8961             using RT = ZeroMatrix<double,columnMajor>;
8962             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8963 
8964             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8965             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8966             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8967          }
8968       }
8969 
8970       // .../DynamicMatrix
8971       {
8972          {
8973             using T1 = ZeroMatrix<int,rowMajor>;
8974             using T2 = DynamicMatrix<double,rowMajor>;
8975             using RT = ZeroMatrix<double,rowMajor>;
8976             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8977 
8978             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8979             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8980             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8981          }
8982          {
8983             using T1 = ZeroMatrix<int,rowMajor>;
8984             using T2 = DynamicMatrix<double,columnMajor>;
8985             using RT = ZeroMatrix<double,rowMajor>;
8986             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8987 
8988             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8989             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
8990             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
8991          }
8992          {
8993             using T1 = ZeroMatrix<int,columnMajor>;
8994             using T2 = DynamicMatrix<double,rowMajor>;
8995             using RT = ZeroMatrix<double,columnMajor>;
8996             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
8997 
8998             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
8999             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9000             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9001          }
9002          {
9003             using T1 = ZeroMatrix<int,columnMajor>;
9004             using T2 = DynamicMatrix<double,columnMajor>;
9005             using RT = ZeroMatrix<double,columnMajor>;
9006             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9007 
9008             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9009             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9010             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9011          }
9012       }
9013 
9014       // .../CustomMatrix
9015       {
9016          {
9017             using T1 = ZeroMatrix<int,rowMajor>;
9018             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
9019             using RT = ZeroMatrix<double,rowMajor>;
9020             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9021 
9022             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9023             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9024             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9025          }
9026          {
9027             using T1 = ZeroMatrix<int,rowMajor>;
9028             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
9029             using RT = ZeroMatrix<double,rowMajor>;
9030             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9031 
9032             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9033             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9034             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9035          }
9036          {
9037             using T1 = ZeroMatrix<int,columnMajor>;
9038             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
9039             using RT = ZeroMatrix<double,columnMajor>;
9040             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9041 
9042             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9043             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9044             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9045          }
9046          {
9047             using T1 = ZeroMatrix<int,columnMajor>;
9048             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
9049             using RT = ZeroMatrix<double,columnMajor>;
9050             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9051 
9052             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9053             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9054             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9055          }
9056       }
9057 
9058       // .../UniformMatrix
9059       {
9060          {
9061             using T1 = ZeroMatrix<int,rowMajor>;
9062             using T2 = UniformMatrix<double,rowMajor>;
9063             using RT = ZeroMatrix<double,rowMajor>;
9064             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9065 
9066             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9067             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9068             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9069          }
9070          {
9071             using T1 = ZeroMatrix<int,rowMajor>;
9072             using T2 = UniformMatrix<double,columnMajor>;
9073             using RT = ZeroMatrix<double,rowMajor>;
9074             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9075 
9076             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9077             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9078             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9079          }
9080          {
9081             using T1 = ZeroMatrix<int,columnMajor>;
9082             using T2 = UniformMatrix<double,rowMajor>;
9083             using RT = ZeroMatrix<double,columnMajor>;
9084             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9085 
9086             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9087             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9088             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9089          }
9090          {
9091             using T1 = ZeroMatrix<int,columnMajor>;
9092             using T2 = UniformMatrix<double,columnMajor>;
9093             using RT = ZeroMatrix<double,columnMajor>;
9094             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9095 
9096             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9097             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9098             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9099          }
9100       }
9101 
9102       // .../InitializerMatrix
9103       {
9104          {
9105             using T1 = ZeroMatrix<int,rowMajor>;
9106             using T2 = InitializerMatrix<double>;
9107             using RT = ZeroMatrix<double,rowMajor>;
9108             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9109 
9110             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9111             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9112             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9113          }
9114          {
9115             using T1 = ZeroMatrix<int,columnMajor>;
9116             using T2 = InitializerMatrix<double>;
9117             using RT = ZeroMatrix<double,columnMajor>;
9118             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9119 
9120             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9121             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9122             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9123          }
9124       }
9125 
9126       // .../CompressedMatrix
9127       {
9128          {
9129             using T1 = ZeroMatrix<int,rowMajor>;
9130             using T2 = CompressedMatrix<double,rowMajor>;
9131             using RT = ZeroMatrix<double,rowMajor>;
9132             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9133 
9134             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9135             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9136             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9137          }
9138          {
9139             using T1 = ZeroMatrix<int,rowMajor>;
9140             using T2 = CompressedMatrix<double,columnMajor>;
9141             using RT = ZeroMatrix<double,rowMajor>;
9142             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9143 
9144             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9145             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9146             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9147          }
9148          {
9149             using T1 = ZeroMatrix<int,columnMajor>;
9150             using T2 = CompressedMatrix<double,rowMajor>;
9151             using RT = ZeroMatrix<double,columnMajor>;
9152             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9153 
9154             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9155             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9156             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9157          }
9158          {
9159             using T1 = ZeroMatrix<int,columnMajor>;
9160             using T2 = CompressedMatrix<double,columnMajor>;
9161             using RT = ZeroMatrix<double,columnMajor>;
9162             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9163 
9164             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9165             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9166             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9167          }
9168       }
9169 
9170       // .../IdentityMatrix
9171       {
9172          {
9173             using T1 = ZeroMatrix<int,rowMajor>;
9174             using T2 = IdentityMatrix<double,rowMajor>;
9175             using RT = ZeroMatrix<double,rowMajor>;
9176             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9177 
9178             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9179             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9180             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9181          }
9182          {
9183             using T1 = ZeroMatrix<int,rowMajor>;
9184             using T2 = IdentityMatrix<double,columnMajor>;
9185             using RT = ZeroMatrix<double,rowMajor>;
9186             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9187 
9188             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9189             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9190             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9191          }
9192          {
9193             using T1 = ZeroMatrix<int,columnMajor>;
9194             using T2 = IdentityMatrix<double,rowMajor>;
9195             using RT = ZeroMatrix<double,columnMajor>;
9196             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9197 
9198             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9199             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9200             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9201          }
9202          {
9203             using T1 = ZeroMatrix<int,columnMajor>;
9204             using T2 = IdentityMatrix<double,columnMajor>;
9205             using RT = ZeroMatrix<double,columnMajor>;
9206             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9207 
9208             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9209             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9210             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9211          }
9212       }
9213 
9214       // .../ZeroMatrix
9215       {
9216          {
9217             using T1 = ZeroMatrix<int,rowMajor>;
9218             using T2 = ZeroMatrix<double,rowMajor>;
9219             using RT = ZeroMatrix<double,rowMajor>;
9220             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9221 
9222             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9223             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9224             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9225          }
9226          {
9227             using T1 = ZeroMatrix<int,rowMajor>;
9228             using T2 = ZeroMatrix<double,columnMajor>;
9229             using RT = ZeroMatrix<double,columnMajor>;
9230             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9231 
9232             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9233             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9234             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9235          }
9236          {
9237             using T1 = ZeroMatrix<int,columnMajor>;
9238             using T2 = ZeroMatrix<double,rowMajor>;
9239             using RT = ZeroMatrix<double,rowMajor>;
9240             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9241 
9242             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9243             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9244             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9245          }
9246          {
9247             using T1 = ZeroMatrix<int,columnMajor>;
9248             using T2 = ZeroMatrix<double,columnMajor>;
9249             using RT = ZeroMatrix<double,columnMajor>;
9250             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9251 
9252             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9253             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9254             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9255          }
9256       }
9257 
9258       // .../SymmetricMatrix<DynamicMatrix> (real)
9259       {
9260          {
9261             using T1 = ZeroMatrix<int,rowMajor>;
9262             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
9263             using RT = ZeroMatrix<double,rowMajor>;
9264             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9265 
9266             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9267             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9268             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9269          }
9270          {
9271             using T1 = ZeroMatrix<int,rowMajor>;
9272             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
9273             using RT = ZeroMatrix<double,rowMajor>;
9274             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9275 
9276             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9277             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9278             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9279          }
9280          {
9281             using T1 = ZeroMatrix<int,columnMajor>;
9282             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
9283             using RT = ZeroMatrix<double,columnMajor>;
9284             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9285 
9286             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9287             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9288             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9289          }
9290          {
9291             using T1 = ZeroMatrix<int,columnMajor>;
9292             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
9293             using RT = ZeroMatrix<double,columnMajor>;
9294             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9295 
9296             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9297             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9298             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9299          }
9300       }
9301 
9302       // .../SymmetricMatrix<DynamicMatrix> (complex)
9303       {
9304          {
9305             using T1 = ZeroMatrix<int,rowMajor>;
9306             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
9307             using RT = ZeroMatrix<complex<int>,rowMajor>;
9308             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9309 
9310             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9311             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9312             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9313          }
9314          {
9315             using T1 = ZeroMatrix<int,rowMajor>;
9316             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
9317             using RT = ZeroMatrix<complex<int>,rowMajor>;
9318             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9319 
9320             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9321             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9322             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9323          }
9324          {
9325             using T1 = ZeroMatrix<int,columnMajor>;
9326             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
9327             using RT = ZeroMatrix<complex<int>,columnMajor>;
9328             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9329 
9330             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9331             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9332             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9333          }
9334          {
9335             using T1 = ZeroMatrix<int,columnMajor>;
9336             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
9337             using RT = ZeroMatrix<complex<int>,columnMajor>;
9338             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9339 
9340             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9341             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9342             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9343          }
9344       }
9345 
9346       // .../SymmetricMatrix<UniformMatrix>
9347       {
9348          {
9349             using T1 = ZeroMatrix<int,rowMajor>;
9350             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
9351             using RT = ZeroMatrix<double,rowMajor>;
9352             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9353 
9354             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9355             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9356             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9357          }
9358          {
9359             using T1 = ZeroMatrix<int,rowMajor>;
9360             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
9361             using RT = ZeroMatrix<double,rowMajor>;
9362             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9363 
9364             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9365             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9366             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9367          }
9368          {
9369             using T1 = ZeroMatrix<int,columnMajor>;
9370             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
9371             using RT = ZeroMatrix<double,columnMajor>;
9372             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9373 
9374             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9375             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9376             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9377          }
9378          {
9379             using T1 = ZeroMatrix<int,columnMajor>;
9380             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
9381             using RT = ZeroMatrix<double,columnMajor>;
9382             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9383 
9384             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9385             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9386             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9387          }
9388       }
9389 
9390       // .../SymmetricMatrix<ZeroMatrix>
9391       {
9392          {
9393             using T1 = ZeroMatrix<int,rowMajor>;
9394             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
9395             using RT = ZeroMatrix<double,rowMajor>;
9396             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9397 
9398             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9399             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9400             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9401          }
9402          {
9403             using T1 = ZeroMatrix<int,rowMajor>;
9404             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
9405             using RT = ZeroMatrix<double,columnMajor>;
9406             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9407 
9408             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9409             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9410             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9411          }
9412          {
9413             using T1 = ZeroMatrix<int,columnMajor>;
9414             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
9415             using RT = ZeroMatrix<double,rowMajor>;
9416             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9417 
9418             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9419             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9420             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9421          }
9422          {
9423             using T1 = ZeroMatrix<int,columnMajor>;
9424             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
9425             using RT = ZeroMatrix<double,columnMajor>;
9426             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9427 
9428             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9429             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9430             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9431          }
9432       }
9433 
9434       // .../HermitianMatrix<DynamicMatrix> (symmetric)
9435       {
9436          {
9437             using T1 = ZeroMatrix<int,rowMajor>;
9438             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
9439             using RT = ZeroMatrix<double,rowMajor>;
9440             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9441 
9442             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9443             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9444             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9445          }
9446          {
9447             using T1 = ZeroMatrix<int,rowMajor>;
9448             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
9449             using RT = ZeroMatrix<double,rowMajor>;
9450             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9451 
9452             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9453             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9454             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9455          }
9456          {
9457             using T1 = ZeroMatrix<int,columnMajor>;
9458             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
9459             using RT = ZeroMatrix<double,columnMajor>;
9460             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9461 
9462             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9463             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9464             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9465          }
9466          {
9467             using T1 = ZeroMatrix<int,columnMajor>;
9468             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
9469             using RT = ZeroMatrix<double,columnMajor>;
9470             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9471 
9472             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9473             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9474             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9475          }
9476       }
9477 
9478       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
9479       {
9480          {
9481             using T1 = ZeroMatrix<int,rowMajor>;
9482             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
9483             using RT = ZeroMatrix<complex<int>,rowMajor>;
9484             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9485 
9486             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9487             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9488             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9489          }
9490          {
9491             using T1 = ZeroMatrix<int,rowMajor>;
9492             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
9493             using RT = ZeroMatrix<complex<int>,rowMajor>;
9494             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9495 
9496             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9497             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9498             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9499          }
9500          {
9501             using T1 = ZeroMatrix<int,columnMajor>;
9502             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
9503             using RT = ZeroMatrix<complex<int>,columnMajor>;
9504             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9505 
9506             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9507             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9508             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9509          }
9510          {
9511             using T1 = ZeroMatrix<int,columnMajor>;
9512             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
9513             using RT = ZeroMatrix<complex<int>,columnMajor>;
9514             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9515 
9516             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9517             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9518             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9519          }
9520       }
9521 
9522       // .../LowerMatrix<DynamicMatrix>
9523       {
9524          {
9525             using T1 = ZeroMatrix<int,rowMajor>;
9526             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
9527             using RT = ZeroMatrix<double,rowMajor>;
9528             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9529 
9530             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9531             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9532             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9533          }
9534          {
9535             using T1 = ZeroMatrix<int,rowMajor>;
9536             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
9537             using RT = ZeroMatrix<double,rowMajor>;
9538             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9539 
9540             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9541             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9542             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9543          }
9544          {
9545             using T1 = ZeroMatrix<int,columnMajor>;
9546             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
9547             using RT = ZeroMatrix<double,columnMajor>;
9548             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9549 
9550             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9551             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9552             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9553          }
9554          {
9555             using T1 = ZeroMatrix<int,columnMajor>;
9556             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
9557             using RT = ZeroMatrix<double,columnMajor>;
9558             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9559 
9560             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9561             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9562             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9563          }
9564       }
9565 
9566       // .../UniLowerMatrix<DynamicMatrix>
9567       {
9568          {
9569             using T1 = ZeroMatrix<int,rowMajor>;
9570             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
9571             using RT = ZeroMatrix<double,rowMajor>;
9572             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9573 
9574             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9575             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9576             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9577          }
9578          {
9579             using T1 = ZeroMatrix<int,rowMajor>;
9580             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
9581             using RT = ZeroMatrix<double,rowMajor>;
9582             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9583 
9584             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9585             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9586             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9587          }
9588          {
9589             using T1 = ZeroMatrix<int,columnMajor>;
9590             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
9591             using RT = ZeroMatrix<double,columnMajor>;
9592             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9593 
9594             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9595             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9596             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9597          }
9598          {
9599             using T1 = ZeroMatrix<int,columnMajor>;
9600             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
9601             using RT = ZeroMatrix<double,columnMajor>;
9602             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9603 
9604             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9605             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9606             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9607          }
9608       }
9609 
9610       // .../StrictlyLowerMatrix<DynamicMatrix>
9611       {
9612          {
9613             using T1 = ZeroMatrix<int,rowMajor>;
9614             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
9615             using RT = ZeroMatrix<double,rowMajor>;
9616             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9617 
9618             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9619             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9620             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9621          }
9622          {
9623             using T1 = ZeroMatrix<int,rowMajor>;
9624             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
9625             using RT = ZeroMatrix<double,rowMajor>;
9626             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9627 
9628             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9629             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9630             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9631          }
9632          {
9633             using T1 = ZeroMatrix<int,columnMajor>;
9634             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
9635             using RT = ZeroMatrix<double,columnMajor>;
9636             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9637 
9638             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9639             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9640             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9641          }
9642          {
9643             using T1 = ZeroMatrix<int,columnMajor>;
9644             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
9645             using RT = ZeroMatrix<double,columnMajor>;
9646             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9647 
9648             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9649             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9650             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9651          }
9652       }
9653 
9654       // .../UpperMatrix<DynamicMatrix>
9655       {
9656          {
9657             using T1 = ZeroMatrix<int,rowMajor>;
9658             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
9659             using RT = ZeroMatrix<double,rowMajor>;
9660             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9661 
9662             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9663             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9664             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9665          }
9666          {
9667             using T1 = ZeroMatrix<int,rowMajor>;
9668             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
9669             using RT = ZeroMatrix<double,rowMajor>;
9670             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9671 
9672             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9673             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9674             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9675          }
9676          {
9677             using T1 = ZeroMatrix<int,columnMajor>;
9678             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
9679             using RT = ZeroMatrix<double,columnMajor>;
9680             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9681 
9682             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9683             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9684             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9685          }
9686          {
9687             using T1 = ZeroMatrix<int,columnMajor>;
9688             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
9689             using RT = ZeroMatrix<double,columnMajor>;
9690             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9691 
9692             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9693             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9694             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9695          }
9696       }
9697 
9698       // .../UniUpperMatrix<DynamicMatrix>
9699       {
9700          {
9701             using T1 = ZeroMatrix<int,rowMajor>;
9702             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
9703             using RT = ZeroMatrix<double,rowMajor>;
9704             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9705 
9706             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9707             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9708             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9709          }
9710          {
9711             using T1 = ZeroMatrix<int,rowMajor>;
9712             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
9713             using RT = ZeroMatrix<double,rowMajor>;
9714             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9715 
9716             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9717             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9718             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9719          }
9720          {
9721             using T1 = ZeroMatrix<int,columnMajor>;
9722             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
9723             using RT = ZeroMatrix<double,columnMajor>;
9724             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9725 
9726             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9727             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9728             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9729          }
9730          {
9731             using T1 = ZeroMatrix<int,columnMajor>;
9732             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
9733             using RT = ZeroMatrix<double,columnMajor>;
9734             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9735 
9736             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9737             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9738             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9739          }
9740       }
9741 
9742       // .../StrictlyUpperMatrix<DynamicMatrix>
9743       {
9744          {
9745             using T1 = ZeroMatrix<int,rowMajor>;
9746             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
9747             using RT = ZeroMatrix<double,rowMajor>;
9748             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9749 
9750             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9751             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9752             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9753          }
9754          {
9755             using T1 = ZeroMatrix<int,rowMajor>;
9756             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
9757             using RT = ZeroMatrix<double,rowMajor>;
9758             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9759 
9760             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9761             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9762             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9763          }
9764          {
9765             using T1 = ZeroMatrix<int,columnMajor>;
9766             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
9767             using RT = ZeroMatrix<double,columnMajor>;
9768             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9769 
9770             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9771             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9772             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9773          }
9774          {
9775             using T1 = ZeroMatrix<int,columnMajor>;
9776             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
9777             using RT = ZeroMatrix<double,columnMajor>;
9778             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9779 
9780             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9781             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9782             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9783          }
9784       }
9785 
9786       // .../DiagonalMatrix<DynamicMatrix>
9787       {
9788          {
9789             using T1 = ZeroMatrix<int,rowMajor>;
9790             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
9791             using RT = ZeroMatrix<double,rowMajor>;
9792             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9793 
9794             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9795             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9796             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9797          }
9798          {
9799             using T1 = ZeroMatrix<int,rowMajor>;
9800             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
9801             using RT = ZeroMatrix<double,rowMajor>;
9802             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9803 
9804             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9805             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9806             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9807          }
9808          {
9809             using T1 = ZeroMatrix<int,columnMajor>;
9810             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
9811             using RT = ZeroMatrix<double,columnMajor>;
9812             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9813 
9814             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9815             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9816             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9817          }
9818          {
9819             using T1 = ZeroMatrix<int,columnMajor>;
9820             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
9821             using RT = ZeroMatrix<double,columnMajor>;
9822             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9823 
9824             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9825             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9826             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9827          }
9828       }
9829    }
9830 
9831    // SymmetricMatrix<DynamicMatrix>/... (real)
9832    {
9833       // .../StaticMatrix
9834       {
9835          {
9836             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9837             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
9838             using RT = DynamicMatrix<double,rowMajor>;
9839             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9840 
9841             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9842             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9843             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9844          }
9845          {
9846             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9847             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
9848             using RT = DynamicMatrix<double,columnMajor>;
9849             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9850 
9851             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9852             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9853             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9854          }
9855          {
9856             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9857             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
9858             using RT = DynamicMatrix<double,rowMajor>;
9859             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9860 
9861             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9862             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9863             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9864          }
9865          {
9866             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9867             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
9868             using RT = DynamicMatrix<double,columnMajor>;
9869             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9870 
9871             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9872             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9873             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9874          }
9875       }
9876 
9877       // .../HybridMatrix
9878       {
9879          {
9880             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9881             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
9882             using RT = DynamicMatrix<double,rowMajor>;
9883             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9884 
9885             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9886             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9887             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9888          }
9889          {
9890             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9891             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
9892             using RT = DynamicMatrix<double,columnMajor>;
9893             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9894 
9895             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9896             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9897             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9898          }
9899          {
9900             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9901             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
9902             using RT = DynamicMatrix<double,rowMajor>;
9903             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9904 
9905             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9906             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9907             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9908          }
9909          {
9910             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9911             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
9912             using RT = DynamicMatrix<double,columnMajor>;
9913             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9914 
9915             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9916             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9917             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9918          }
9919       }
9920 
9921       // .../DynamicMatrix
9922       {
9923          {
9924             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9925             using T2 = DynamicMatrix<double,rowMajor>;
9926             using RT = DynamicMatrix<double,rowMajor>;
9927             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9928 
9929             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9930             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9931             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9932          }
9933          {
9934             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9935             using T2 = DynamicMatrix<double,columnMajor>;
9936             using RT = DynamicMatrix<double,columnMajor>;
9937             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9938 
9939             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9940             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9941             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9942          }
9943          {
9944             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9945             using T2 = DynamicMatrix<double,rowMajor>;
9946             using RT = DynamicMatrix<double,rowMajor>;
9947             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9948 
9949             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9950             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9951             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9952          }
9953          {
9954             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9955             using T2 = DynamicMatrix<double,columnMajor>;
9956             using RT = DynamicMatrix<double,columnMajor>;
9957             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9958 
9959             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9960             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9961             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9962          }
9963       }
9964 
9965       // .../CustomMatrix
9966       {
9967          {
9968             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9969             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
9970             using RT = DynamicMatrix<double,rowMajor>;
9971             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9972 
9973             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9974             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9975             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9976          }
9977          {
9978             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
9979             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
9980             using RT = DynamicMatrix<double,columnMajor>;
9981             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9982 
9983             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9984             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9985             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9986          }
9987          {
9988             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9989             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
9990             using RT = DynamicMatrix<double,rowMajor>;
9991             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
9992 
9993             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
9994             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
9995             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
9996          }
9997          {
9998             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
9999             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
10000             using RT = DynamicMatrix<double,columnMajor>;
10001             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10002 
10003             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10004             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10005             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10006          }
10007       }
10008 
10009       // .../UniformMatrix
10010       {
10011          {
10012             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10013             using T2 = UniformMatrix<double,rowMajor>;
10014             using RT = DynamicMatrix<double,rowMajor>;
10015             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10016 
10017             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10018             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10019             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10020          }
10021          {
10022             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10023             using T2 = UniformMatrix<double,columnMajor>;
10024             using RT = DynamicMatrix<double,columnMajor>;
10025             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10026 
10027             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10028             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10029             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10030          }
10031          {
10032             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10033             using T2 = UniformMatrix<double,rowMajor>;
10034             using RT = DynamicMatrix<double,rowMajor>;
10035             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10036 
10037             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10038             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10039             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10040          }
10041          {
10042             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10043             using T2 = UniformMatrix<double,columnMajor>;
10044             using RT = DynamicMatrix<double,columnMajor>;
10045             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10046 
10047             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10048             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10049             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10050          }
10051       }
10052 
10053       // .../InitializerMatrix
10054       {
10055          {
10056             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10057             using T2 = InitializerMatrix<double>;
10058             using RT = DynamicMatrix<double,rowMajor>;
10059             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10060 
10061             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10062             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10063             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10064          }
10065          {
10066             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10067             using T2 = InitializerMatrix<double>;
10068             using RT = DynamicMatrix<double,rowMajor>;
10069             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10070 
10071             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10072             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10073             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10074          }
10075       }
10076 
10077       // .../CompressedMatrix
10078       {
10079          {
10080             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10081             using T2 = CompressedMatrix<double,rowMajor>;
10082             using RT = CompressedMatrix<double,rowMajor>;
10083             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10084 
10085             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10086             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10087             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10088          }
10089          {
10090             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10091             using T2 = CompressedMatrix<double,columnMajor>;
10092             using RT = CompressedMatrix<double,columnMajor>;
10093             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10094 
10095             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10096             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10097             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10098          }
10099          {
10100             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10101             using T2 = CompressedMatrix<double,rowMajor>;
10102             using RT = CompressedMatrix<double,rowMajor>;
10103             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10104 
10105             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10106             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10107             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10108          }
10109          {
10110             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10111             using T2 = CompressedMatrix<double,columnMajor>;
10112             using RT = CompressedMatrix<double,columnMajor>;
10113             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10114 
10115             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10116             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10117             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10118          }
10119       }
10120 
10121       // .../IdentityMatrix
10122       {
10123          {
10124             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10125             using T2 = IdentityMatrix<double,rowMajor>;
10126             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
10127             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10128 
10129             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10130             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10131             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10132          }
10133          {
10134             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10135             using T2 = IdentityMatrix<double,columnMajor>;
10136             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
10137             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10138 
10139             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10140             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10141             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10142          }
10143          {
10144             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10145             using T2 = IdentityMatrix<double,rowMajor>;
10146             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
10147             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10148 
10149             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10150             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10151             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10152          }
10153          {
10154             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10155             using T2 = IdentityMatrix<double,columnMajor>;
10156             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
10157             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10158 
10159             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10160             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10161             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10162          }
10163       }
10164 
10165       // .../ZeroMatrix
10166       {
10167          {
10168             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10169             using T2 = ZeroMatrix<double,rowMajor>;
10170             using RT = ZeroMatrix<double,rowMajor>;
10171             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10172 
10173             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10174             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10175             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10176          }
10177          {
10178             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10179             using T2 = ZeroMatrix<double,columnMajor>;
10180             using RT = ZeroMatrix<double,columnMajor>;
10181             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10182 
10183             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10184             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10185             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10186          }
10187          {
10188             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10189             using T2 = ZeroMatrix<double,rowMajor>;
10190             using RT = ZeroMatrix<double,rowMajor>;
10191             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10192 
10193             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10194             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10195             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10196          }
10197          {
10198             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10199             using T2 = ZeroMatrix<double,columnMajor>;
10200             using RT = ZeroMatrix<double,columnMajor>;
10201             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10202 
10203             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10204             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10205             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10206          }
10207       }
10208 
10209       // .../SymmetricMatrix<DynamicMatrix> (real)
10210       {
10211          {
10212             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10213             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10214             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10215             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10216 
10217             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10218             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10219             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10220          }
10221          {
10222             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10223             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10224             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10225             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10226 
10227             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10228             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10229             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10230          }
10231          {
10232             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10233             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10234             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10235             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10236 
10237             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10238             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10239             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10240          }
10241          {
10242             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10243             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10244             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10245             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10246 
10247             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10248             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10249             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10250          }
10251       }
10252 
10253       // .../SymmetricMatrix<DynamicMatrix> (complex)
10254       {
10255          {
10256             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10257             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10258             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10259             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10260 
10261             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10262             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10263             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10264          }
10265          {
10266             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10267             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10268             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10269             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10270 
10271             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10272             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10273             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10274          }
10275          {
10276             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10277             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10278             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10279             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10280 
10281             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10282             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10283             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10284          }
10285          {
10286             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10287             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10288             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10289             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10290 
10291             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10292             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10293             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10294          }
10295       }
10296 
10297       // .../SymmetricMatrix<UniformMatrix>
10298       {
10299          {
10300             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10301             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
10302             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10303             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10304 
10305             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10306             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10307             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10308          }
10309          {
10310             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10311             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
10312             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10313             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10314 
10315             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10316             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10317             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10318          }
10319          {
10320             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10321             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
10322             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10323             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10324 
10325             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10326             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10327             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10328          }
10329          {
10330             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10331             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
10332             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10333             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10334 
10335             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10336             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10337             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10338          }
10339       }
10340 
10341       // .../SymmetricMatrix<ZeroMatrix>
10342       {
10343          {
10344             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10345             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
10346             using RT = ZeroMatrix<double,rowMajor>;
10347             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10348 
10349             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10350             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10351             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10352          }
10353          {
10354             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10355             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
10356             using RT = ZeroMatrix<double,columnMajor>;
10357             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10358 
10359             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10360             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10361             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10362          }
10363          {
10364             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10365             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
10366             using RT = ZeroMatrix<double,rowMajor>;
10367             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10368 
10369             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10370             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10371             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10372          }
10373          {
10374             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10375             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
10376             using RT = ZeroMatrix<double,columnMajor>;
10377             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10378 
10379             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10380             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10381             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10382          }
10383       }
10384 
10385       // .../HermitianMatrix<DynamicMatrix> (symmetric)
10386       {
10387          {
10388             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10389             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
10390             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10391             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10392 
10393             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10394             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10395             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10396          }
10397          {
10398             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10399             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
10400             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10401             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10402 
10403             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10404             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10405             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10406          }
10407          {
10408             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10409             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
10410             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10411             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10412 
10413             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10414             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10415             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10416          }
10417          {
10418             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10419             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
10420             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10421             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10422 
10423             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10424             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10425             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10426          }
10427       }
10428 
10429       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
10430       {
10431          {
10432             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10433             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10434             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10435             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10436 
10437             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10438             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10439             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10440          }
10441          {
10442             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10443             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10444             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10445             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10446 
10447             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10448             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10449             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10450          }
10451          {
10452             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10453             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10454             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10455             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10456 
10457             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10458             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10459             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10460          }
10461          {
10462             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10463             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10464             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10465             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10466 
10467             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10468             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10469             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10470          }
10471       }
10472 
10473       // .../LowerMatrix<DynamicMatrix>
10474       {
10475          {
10476             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10477             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
10478             using RT = DynamicMatrix<double,rowMajor>;
10479             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10480 
10481             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10482             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10483             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10484          }
10485          {
10486             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10487             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
10488             using RT = DynamicMatrix<double,columnMajor>;
10489             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10490 
10491             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10492             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10493             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10494          }
10495          {
10496             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10497             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
10498             using RT = DynamicMatrix<double,rowMajor>;
10499             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10500 
10501             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10502             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10503             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10504          }
10505          {
10506             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10507             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
10508             using RT = DynamicMatrix<double,columnMajor>;
10509             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10510 
10511             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10512             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10513             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10514          }
10515       }
10516 
10517       // .../UniLowerMatrix<DynamicMatrix>
10518       {
10519          {
10520             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10521             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
10522             using RT = DynamicMatrix<double,rowMajor>;
10523             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10524 
10525             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10526             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10527             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10528          }
10529          {
10530             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10531             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
10532             using RT = DynamicMatrix<double,columnMajor>;
10533             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10534 
10535             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10536             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10537             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10538          }
10539          {
10540             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10541             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
10542             using RT = DynamicMatrix<double,rowMajor>;
10543             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10544 
10545             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10546             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10547             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10548          }
10549          {
10550             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10551             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
10552             using RT = DynamicMatrix<double,columnMajor>;
10553             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10554 
10555             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10556             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10557             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10558          }
10559       }
10560 
10561       // .../StrictlyLowerMatrix<DynamicMatrix>
10562       {
10563          {
10564             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10565             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
10566             using RT = DynamicMatrix<double,rowMajor>;
10567             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10568 
10569             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10570             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10571             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10572          }
10573          {
10574             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10575             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
10576             using RT = DynamicMatrix<double,columnMajor>;
10577             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10578 
10579             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10580             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10581             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10582          }
10583          {
10584             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10585             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
10586             using RT = DynamicMatrix<double,rowMajor>;
10587             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10588 
10589             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10590             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10591             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10592          }
10593          {
10594             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10595             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
10596             using RT = DynamicMatrix<double,columnMajor>;
10597             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10598 
10599             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10600             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10601             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10602          }
10603       }
10604 
10605       // .../UpperMatrix<DynamicMatrix>
10606       {
10607          {
10608             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10609             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
10610             using RT = DynamicMatrix<double,rowMajor>;
10611             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10612 
10613             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10614             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10615             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10616          }
10617          {
10618             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10619             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
10620             using RT = DynamicMatrix<double,columnMajor>;
10621             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10622 
10623             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10624             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10625             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10626          }
10627          {
10628             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10629             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
10630             using RT = DynamicMatrix<double,rowMajor>;
10631             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10632 
10633             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10634             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10635             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10636          }
10637          {
10638             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10639             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
10640             using RT = DynamicMatrix<double,columnMajor>;
10641             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10642 
10643             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10644             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10645             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10646          }
10647       }
10648 
10649       // .../UniUpperMatrix<DynamicMatrix>
10650       {
10651          {
10652             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10653             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
10654             using RT = DynamicMatrix<double,rowMajor>;
10655             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10656 
10657             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10658             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10659             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10660          }
10661          {
10662             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10663             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
10664             using RT = DynamicMatrix<double,columnMajor>;
10665             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10666 
10667             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10668             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10669             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10670          }
10671          {
10672             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10673             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
10674             using RT = DynamicMatrix<double,rowMajor>;
10675             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10676 
10677             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10678             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10679             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10680          }
10681          {
10682             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10683             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
10684             using RT = DynamicMatrix<double,columnMajor>;
10685             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10686 
10687             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10688             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10689             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10690          }
10691       }
10692 
10693       // .../StrictlyUpperMatrix<DynamicMatrix>
10694       {
10695          {
10696             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10697             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
10698             using RT = DynamicMatrix<double,rowMajor>;
10699             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10700 
10701             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10702             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10703             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10704          }
10705          {
10706             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10707             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
10708             using RT = DynamicMatrix<double,columnMajor>;
10709             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10710 
10711             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10712             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10713             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10714          }
10715          {
10716             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10717             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
10718             using RT = DynamicMatrix<double,rowMajor>;
10719             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10720 
10721             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10722             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10723             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10724          }
10725          {
10726             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10727             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
10728             using RT = DynamicMatrix<double,columnMajor>;
10729             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10730 
10731             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10732             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10733             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10734          }
10735       }
10736 
10737       // .../DiagonalMatrix<DynamicMatrix>
10738       {
10739          {
10740             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10741             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
10742             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10743             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10744 
10745             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10746             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10747             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10748          }
10749          {
10750             using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
10751             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
10752             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10753             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10754 
10755             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10756             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10757             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10758          }
10759          {
10760             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10761             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
10762             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
10763             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10764 
10765             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10766             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10767             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10768          }
10769          {
10770             using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
10771             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
10772             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
10773             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10774 
10775             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10776             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10777             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10778          }
10779       }
10780    }
10781 
10782    // SymmetricMatrix<DynamicMatrix>/... (complex)
10783    {
10784       // .../StaticMatrix
10785       {
10786          {
10787             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10788             using T2 = StaticMatrix<int,3UL,3UL,rowMajor>;
10789             using RT = DynamicMatrix<complex<int>,rowMajor>;
10790             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10791 
10792             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10793             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10794             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10795          }
10796          {
10797             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10798             using T2 = StaticMatrix<int,3UL,3UL,columnMajor>;
10799             using RT = DynamicMatrix<complex<int>,columnMajor>;
10800             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10801 
10802             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10803             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10804             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10805          }
10806          {
10807             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10808             using T2 = StaticMatrix<int,3UL,3UL,rowMajor>;
10809             using RT = DynamicMatrix<complex<int>,rowMajor>;
10810             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10811 
10812             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10813             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10814             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10815          }
10816          {
10817             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10818             using T2 = StaticMatrix<int,3UL,3UL,columnMajor>;
10819             using RT = DynamicMatrix<complex<int>,columnMajor>;
10820             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10821 
10822             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10823             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10824             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10825          }
10826       }
10827 
10828       // .../HybridMatrix
10829       {
10830          {
10831             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10832             using T2 = HybridMatrix<int,8UL,6UL,rowMajor>;
10833             using RT = DynamicMatrix<complex<int>,rowMajor>;
10834             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10835 
10836             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10837             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10838             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10839          }
10840          {
10841             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10842             using T2 = HybridMatrix<int,8UL,6UL,columnMajor>;
10843             using RT = DynamicMatrix<complex<int>,columnMajor>;
10844             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10845 
10846             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10847             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10848             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10849          }
10850          {
10851             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10852             using T2 = HybridMatrix<int,8UL,6UL,rowMajor>;
10853             using RT = DynamicMatrix<complex<int>,rowMajor>;
10854             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10855 
10856             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10857             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10858             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10859          }
10860          {
10861             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10862             using T2 = HybridMatrix<int,8UL,6UL,columnMajor>;
10863             using RT = DynamicMatrix<complex<int>,columnMajor>;
10864             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10865 
10866             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10867             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10868             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10869          }
10870       }
10871 
10872       // .../DynamicMatrix
10873       {
10874          {
10875             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10876             using T2 = DynamicMatrix<int,rowMajor>;
10877             using RT = DynamicMatrix<complex<int>,rowMajor>;
10878             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10879 
10880             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10881             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10882             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10883          }
10884          {
10885             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10886             using T2 = DynamicMatrix<int,columnMajor>;
10887             using RT = DynamicMatrix<complex<int>,columnMajor>;
10888             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10889 
10890             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10891             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10892             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10893          }
10894          {
10895             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10896             using T2 = DynamicMatrix<int,rowMajor>;
10897             using RT = DynamicMatrix<complex<int>,rowMajor>;
10898             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10899 
10900             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10901             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10902             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10903          }
10904          {
10905             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10906             using T2 = DynamicMatrix<int,columnMajor>;
10907             using RT = DynamicMatrix<complex<int>,columnMajor>;
10908             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10909 
10910             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10911             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10912             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10913          }
10914       }
10915 
10916       // .../CustomMatrix
10917       {
10918          {
10919             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10920             using T2 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
10921             using RT = DynamicMatrix<complex<int>,rowMajor>;
10922             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10923 
10924             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10925             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10926             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10927          }
10928          {
10929             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10930             using T2 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
10931             using RT = DynamicMatrix<complex<int>,columnMajor>;
10932             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10933 
10934             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10935             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10936             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10937          }
10938          {
10939             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10940             using T2 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
10941             using RT = DynamicMatrix<complex<int>,rowMajor>;
10942             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10943 
10944             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10945             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10946             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10947          }
10948          {
10949             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10950             using T2 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
10951             using RT = DynamicMatrix<complex<int>,columnMajor>;
10952             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10953 
10954             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10955             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10956             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10957          }
10958       }
10959 
10960       // .../UniformMatrix
10961       {
10962          {
10963             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10964             using T2 = UniformMatrix<int,rowMajor>;
10965             using RT = DynamicMatrix<complex<int>,rowMajor>;
10966             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10967 
10968             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10969             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10970             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10971          }
10972          {
10973             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
10974             using T2 = UniformMatrix<int,columnMajor>;
10975             using RT = DynamicMatrix<complex<int>,columnMajor>;
10976             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10977 
10978             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10979             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10980             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10981          }
10982          {
10983             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10984             using T2 = UniformMatrix<int,rowMajor>;
10985             using RT = DynamicMatrix<complex<int>,rowMajor>;
10986             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10987 
10988             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10989             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
10990             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
10991          }
10992          {
10993             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
10994             using T2 = UniformMatrix<int,columnMajor>;
10995             using RT = DynamicMatrix<complex<int>,columnMajor>;
10996             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
10997 
10998             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
10999             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11000             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11001          }
11002       }
11003 
11004       // .../InitializerMatrix
11005       {
11006          {
11007             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11008             using T2 = InitializerMatrix<int>;
11009             using RT = DynamicMatrix<complex<int>,rowMajor>;
11010             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11011 
11012             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11013             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11014             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11015          }
11016          {
11017             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11018             using T2 = InitializerMatrix<int>;
11019             using RT = DynamicMatrix<complex<int>,rowMajor>;
11020             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11021 
11022             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11023             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11024             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11025          }
11026       }
11027 
11028       // .../CompressedMatrix
11029       {
11030          {
11031             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11032             using T2 = CompressedMatrix<int,rowMajor>;
11033             using RT = CompressedMatrix<complex<int>,rowMajor>;
11034             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11035 
11036             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11037             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11038             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11039          }
11040          {
11041             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11042             using T2 = CompressedMatrix<int,columnMajor>;
11043             using RT = CompressedMatrix<complex<int>,columnMajor>;
11044             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11045 
11046             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11047             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11048             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11049          }
11050          {
11051             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11052             using T2 = CompressedMatrix<int,rowMajor>;
11053             using RT = CompressedMatrix<complex<int>,rowMajor>;
11054             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11055 
11056             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11057             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11058             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11059          }
11060          {
11061             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11062             using T2 = CompressedMatrix<int,columnMajor>;
11063             using RT = CompressedMatrix<complex<int>,columnMajor>;
11064             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11065 
11066             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11067             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11068             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11069          }
11070       }
11071 
11072       // .../IdentityMatrix
11073       {
11074          {
11075             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11076             using T2 = IdentityMatrix<int,rowMajor>;
11077             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,rowMajor> >;
11078             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11079 
11080             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11081             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11082             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11083          }
11084          {
11085             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11086             using T2 = IdentityMatrix<int,columnMajor>;
11087             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,columnMajor> >;
11088             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11089 
11090             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11091             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11092             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11093          }
11094          {
11095             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11096             using T2 = IdentityMatrix<int,rowMajor>;
11097             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,rowMajor> >;
11098             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11099 
11100             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11101             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11102             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11103          }
11104          {
11105             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11106             using T2 = IdentityMatrix<int,columnMajor>;
11107             using RT = SymmetricMatrix< CompressedMatrix<complex<int>,columnMajor> >;
11108             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11109 
11110             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11111             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11112             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11113          }
11114       }
11115 
11116       // .../ZeroMatrix
11117       {
11118          {
11119             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11120             using T2 = ZeroMatrix<int,rowMajor>;
11121             using RT = ZeroMatrix<complex<int>,rowMajor>;
11122             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11123 
11124             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11125             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11126             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11127          }
11128          {
11129             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11130             using T2 = ZeroMatrix<int,columnMajor>;
11131             using RT = ZeroMatrix<complex<int>,columnMajor>;
11132             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11133 
11134             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11135             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11136             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11137          }
11138          {
11139             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11140             using T2 = ZeroMatrix<int,rowMajor>;
11141             using RT = ZeroMatrix<complex<int>,rowMajor>;
11142             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11143 
11144             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11145             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11146             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11147          }
11148          {
11149             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11150             using T2 = ZeroMatrix<int,columnMajor>;
11151             using RT = ZeroMatrix<complex<int>,columnMajor>;
11152             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11153 
11154             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11155             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11156             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11157          }
11158       }
11159 
11160       // .../SymmetricMatrix<DynamicMatrix> (real)
11161       {
11162          {
11163             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11164             using T2 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
11165             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11166             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11167 
11168             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11169             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11170             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11171          }
11172          {
11173             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11174             using T2 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
11175             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11176             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11177 
11178             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11179             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11180             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11181          }
11182          {
11183             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11184             using T2 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
11185             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11186             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11187 
11188             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11189             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11190             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11191          }
11192          {
11193             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11194             using T2 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
11195             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11196             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11197 
11198             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11199             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11200             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11201          }
11202       }
11203 
11204       // .../SymmetricMatrix<DynamicMatrix> (complex)
11205       {
11206          {
11207             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11208             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11209             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11210             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11211 
11212             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11213             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11214             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11215          }
11216          {
11217             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11218             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11219             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11220             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11221 
11222             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11223             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11224             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11225          }
11226          {
11227             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11228             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11229             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11230             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11231 
11232             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11233             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11234             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11235          }
11236          {
11237             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11238             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11239             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11240             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11241 
11242             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11243             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11244             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11245          }
11246       }
11247 
11248       // .../SymmetricMatrix<UniformMatrix>
11249       {
11250          {
11251             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11252             using T2 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11253             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11254             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11255 
11256             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11257             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11258             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11259          }
11260          {
11261             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11262             using T2 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11263             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11264             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11265 
11266             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11267             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11268             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11269          }
11270          {
11271             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11272             using T2 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11273             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11274             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11275 
11276             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11277             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11278             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11279          }
11280          {
11281             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11282             using T2 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11283             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11284             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11285 
11286             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11287             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11288             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11289          }
11290       }
11291 
11292       // .../SymmetricMatrix<ZeroMatrix>
11293       {
11294          {
11295             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11296             using T2 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
11297             using RT = ZeroMatrix<complex<int>,rowMajor>;
11298             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11299 
11300             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11301             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11302             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11303          }
11304          {
11305             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11306             using T2 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
11307             using RT = ZeroMatrix<complex<int>,columnMajor>;
11308             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11309 
11310             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11311             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11312             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11313          }
11314          {
11315             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11316             using T2 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
11317             using RT = ZeroMatrix<complex<int>,rowMajor>;
11318             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11319 
11320             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11321             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11322             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11323          }
11324          {
11325             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11326             using T2 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
11327             using RT = ZeroMatrix<complex<int>,columnMajor>;
11328             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11329 
11330             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11331             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11332             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11333          }
11334       }
11335 
11336       // .../HermitianMatrix<DynamicMatrix> (symmetric)
11337       {
11338          {
11339             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11340             using T2 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
11341             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11342             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11343 
11344             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11345             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11346             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11347          }
11348          {
11349             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11350             using T2 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
11351             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11352             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11353 
11354             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11355             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11356             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11357          }
11358          {
11359             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11360             using T2 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
11361             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11362             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11363 
11364             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11365             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11366             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11367          }
11368          {
11369             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11370             using T2 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
11371             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11372             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11373 
11374             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11375             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11376             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11377          }
11378       }
11379 
11380       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
11381       {
11382          {
11383             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11384             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11385             using RT = DynamicMatrix<complex<int>,rowMajor>;
11386             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11387 
11388             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11389             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11390             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11391          }
11392          {
11393             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11394             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11395             using RT = DynamicMatrix<complex<int>,columnMajor>;
11396             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11397 
11398             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11399             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11400             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11401          }
11402          {
11403             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11404             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11405             using RT = DynamicMatrix<complex<int>,rowMajor>;
11406             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11407 
11408             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11409             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11410             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11411          }
11412          {
11413             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11414             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11415             using RT = DynamicMatrix<complex<int>,columnMajor>;
11416             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11417 
11418             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11419             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11420             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11421          }
11422       }
11423 
11424       // .../LowerMatrix<DynamicMatrix>
11425       {
11426          {
11427             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11428             using T2 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
11429             using RT = DynamicMatrix<complex<int>,rowMajor>;
11430             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11431 
11432             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11433             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11434             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11435          }
11436          {
11437             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11438             using T2 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
11439             using RT = DynamicMatrix<complex<int>,columnMajor>;
11440             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11441 
11442             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11443             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11444             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11445          }
11446          {
11447             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11448             using T2 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
11449             using RT = DynamicMatrix<complex<int>,rowMajor>;
11450             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11451 
11452             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11453             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11454             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11455          }
11456          {
11457             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11458             using T2 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
11459             using RT = DynamicMatrix<complex<int>,columnMajor>;
11460             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11461 
11462             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11463             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11464             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11465          }
11466       }
11467 
11468       // .../UniLowerMatrix<DynamicMatrix>
11469       {
11470          {
11471             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11472             using T2 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
11473             using RT = DynamicMatrix<complex<int>,rowMajor>;
11474             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11475 
11476             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11477             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11478             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11479          }
11480          {
11481             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11482             using T2 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
11483             using RT = DynamicMatrix<complex<int>,columnMajor>;
11484             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11485 
11486             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11487             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11488             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11489          }
11490          {
11491             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11492             using T2 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
11493             using RT = DynamicMatrix<complex<int>,rowMajor>;
11494             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11495 
11496             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11497             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11498             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11499          }
11500          {
11501             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11502             using T2 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
11503             using RT = DynamicMatrix<complex<int>,columnMajor>;
11504             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11505 
11506             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11507             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11508             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11509          }
11510       }
11511 
11512       // .../StrictlyLowerMatrix<DynamicMatrix>
11513       {
11514          {
11515             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11516             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
11517             using RT = DynamicMatrix<complex<int>,rowMajor>;
11518             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11519 
11520             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11521             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11522             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11523          }
11524          {
11525             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11526             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
11527             using RT = DynamicMatrix<complex<int>,columnMajor>;
11528             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11529 
11530             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11531             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11532             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11533          }
11534          {
11535             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11536             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
11537             using RT = DynamicMatrix<complex<int>,rowMajor>;
11538             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11539 
11540             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11541             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11542             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11543          }
11544          {
11545             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11546             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
11547             using RT = DynamicMatrix<complex<int>,columnMajor>;
11548             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11549 
11550             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11551             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11552             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11553          }
11554       }
11555 
11556       // .../UpperMatrix<DynamicMatrix>
11557       {
11558          {
11559             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11560             using T2 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
11561             using RT = DynamicMatrix<complex<int>,rowMajor>;
11562             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11563 
11564             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11565             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11566             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11567          }
11568          {
11569             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11570             using T2 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
11571             using RT = DynamicMatrix<complex<int>,columnMajor>;
11572             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11573 
11574             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11575             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11576             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11577          }
11578          {
11579             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11580             using T2 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
11581             using RT = DynamicMatrix<complex<int>,rowMajor>;
11582             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11583 
11584             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11585             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11586             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11587          }
11588          {
11589             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11590             using T2 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
11591             using RT = DynamicMatrix<complex<int>,columnMajor>;
11592             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11593 
11594             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11595             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11596             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11597          }
11598       }
11599 
11600       // .../UniUpperMatrix<DynamicMatrix>
11601       {
11602          {
11603             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11604             using T2 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
11605             using RT = DynamicMatrix<complex<int>,rowMajor>;
11606             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11607 
11608             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11609             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11610             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11611          }
11612          {
11613             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11614             using T2 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
11615             using RT = DynamicMatrix<complex<int>,columnMajor>;
11616             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11617 
11618             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11619             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11620             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11621          }
11622          {
11623             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11624             using T2 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
11625             using RT = DynamicMatrix<complex<int>,rowMajor>;
11626             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11627 
11628             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11629             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11630             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11631          }
11632          {
11633             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11634             using T2 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
11635             using RT = DynamicMatrix<complex<int>,columnMajor>;
11636             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11637 
11638             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11639             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11640             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11641          }
11642       }
11643 
11644       // .../StrictlyUpperMatrix<DynamicMatrix>
11645       {
11646          {
11647             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11648             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
11649             using RT = DynamicMatrix<complex<int>,rowMajor>;
11650             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11651 
11652             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11653             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11654             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11655          }
11656          {
11657             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11658             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
11659             using RT = DynamicMatrix<complex<int>,columnMajor>;
11660             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11661 
11662             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11663             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11664             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11665          }
11666          {
11667             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11668             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
11669             using RT = DynamicMatrix<complex<int>,rowMajor>;
11670             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11671 
11672             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11673             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11674             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11675          }
11676          {
11677             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11678             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
11679             using RT = DynamicMatrix<complex<int>,columnMajor>;
11680             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11681 
11682             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11683             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11684             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11685          }
11686       }
11687 
11688       // .../DiagonalMatrix<DynamicMatrix>
11689       {
11690          {
11691             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11692             using T2 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
11693             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11694             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11695 
11696             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11697             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11698             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11699          }
11700          {
11701             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11702             using T2 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
11703             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11704             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11705 
11706             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11707             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11708             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11709          }
11710          {
11711             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11712             using T2 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
11713             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
11714             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11715 
11716             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11717             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11718             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11719          }
11720          {
11721             using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11722             using T2 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
11723             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
11724             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11725 
11726             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11727             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11728             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11729          }
11730       }
11731    }
11732 
11733    // SymmetricMatrix<UniformMatrix>/...
11734    {
11735       // .../StaticMatrix
11736       {
11737          {
11738             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11739             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
11740             using RT = DynamicMatrix<double,rowMajor>;
11741             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11742 
11743             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11744             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11745             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11746          }
11747          {
11748             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11749             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
11750             using RT = DynamicMatrix<double,columnMajor>;
11751             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11752 
11753             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11754             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11755             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11756          }
11757          {
11758             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11759             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
11760             using RT = DynamicMatrix<double,rowMajor>;
11761             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11762 
11763             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11764             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11765             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11766          }
11767          {
11768             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11769             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
11770             using RT = DynamicMatrix<double,columnMajor>;
11771             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11772 
11773             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11774             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11775             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11776          }
11777       }
11778 
11779       // .../HybridMatrix
11780       {
11781          {
11782             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11783             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
11784             using RT = DynamicMatrix<double,rowMajor>;
11785             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11786 
11787             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11788             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11789             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11790          }
11791          {
11792             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11793             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
11794             using RT = DynamicMatrix<double,columnMajor>;
11795             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11796 
11797             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11798             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11799             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11800          }
11801          {
11802             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11803             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
11804             using RT = DynamicMatrix<double,rowMajor>;
11805             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11806 
11807             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11808             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11809             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11810          }
11811          {
11812             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11813             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
11814             using RT = DynamicMatrix<double,columnMajor>;
11815             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11816 
11817             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11818             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11819             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11820          }
11821       }
11822 
11823       // .../DynamicMatrix
11824       {
11825          {
11826             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11827             using T2 = DynamicMatrix<double,rowMajor>;
11828             using RT = DynamicMatrix<double,rowMajor>;
11829             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11830 
11831             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11832             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11833             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11834          }
11835          {
11836             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11837             using T2 = DynamicMatrix<double,columnMajor>;
11838             using RT = DynamicMatrix<double,columnMajor>;
11839             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11840 
11841             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11842             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11843             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11844          }
11845          {
11846             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11847             using T2 = DynamicMatrix<double,rowMajor>;
11848             using RT = DynamicMatrix<double,rowMajor>;
11849             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11850 
11851             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11852             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11853             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11854          }
11855          {
11856             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11857             using T2 = DynamicMatrix<double,columnMajor>;
11858             using RT = DynamicMatrix<double,columnMajor>;
11859             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11860 
11861             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11862             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11863             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11864          }
11865       }
11866 
11867       // .../CustomMatrix
11868       {
11869          {
11870             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11871             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
11872             using RT = DynamicMatrix<double,rowMajor>;
11873             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11874 
11875             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11876             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11877             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11878          }
11879          {
11880             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11881             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
11882             using RT = DynamicMatrix<double,columnMajor>;
11883             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11884 
11885             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11886             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11887             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11888          }
11889          {
11890             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11891             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
11892             using RT = DynamicMatrix<double,rowMajor>;
11893             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11894 
11895             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11896             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11897             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11898          }
11899          {
11900             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11901             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
11902             using RT = DynamicMatrix<double,columnMajor>;
11903             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11904 
11905             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11906             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11907             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11908          }
11909       }
11910 
11911       // .../UniformMatrix
11912       {
11913          {
11914             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11915             using T2 = UniformMatrix<double,rowMajor>;
11916             using RT = UniformMatrix<double,rowMajor>;
11917             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11918 
11919             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11920             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11921             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11922          }
11923          {
11924             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11925             using T2 = UniformMatrix<double,columnMajor>;
11926             using RT = UniformMatrix<double,columnMajor>;
11927             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11928 
11929             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11930             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11931             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11932          }
11933          {
11934             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11935             using T2 = UniformMatrix<double,rowMajor>;
11936             using RT = UniformMatrix<double,rowMajor>;
11937             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11938 
11939             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11940             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11941             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11942          }
11943          {
11944             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11945             using T2 = UniformMatrix<double,columnMajor>;
11946             using RT = UniformMatrix<double,columnMajor>;
11947             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11948 
11949             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11950             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11951             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11952          }
11953       }
11954 
11955       // .../InitializerMatrix
11956       {
11957          {
11958             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11959             using T2 = InitializerMatrix<double>;
11960             using RT = DynamicMatrix<double,rowMajor>;
11961             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11962 
11963             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11964             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11965             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11966          }
11967          {
11968             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
11969             using T2 = InitializerMatrix<double>;
11970             using RT = DynamicMatrix<double,rowMajor>;
11971             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11972 
11973             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11974             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11975             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11976          }
11977       }
11978 
11979       // .../CompressedMatrix
11980       {
11981          {
11982             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11983             using T2 = CompressedMatrix<double,rowMajor>;
11984             using RT = CompressedMatrix<double,rowMajor>;
11985             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11986 
11987             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11988             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11989             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
11990          }
11991          {
11992             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
11993             using T2 = CompressedMatrix<double,columnMajor>;
11994             using RT = CompressedMatrix<double,columnMajor>;
11995             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
11996 
11997             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
11998             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
11999             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12000          }
12001          {
12002             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12003             using T2 = CompressedMatrix<double,rowMajor>;
12004             using RT = CompressedMatrix<double,rowMajor>;
12005             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12006 
12007             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12008             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12009             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12010          }
12011          {
12012             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12013             using T2 = CompressedMatrix<double,columnMajor>;
12014             using RT = CompressedMatrix<double,columnMajor>;
12015             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12016 
12017             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12018             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12019             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12020          }
12021       }
12022 
12023       // .../IdentityMatrix
12024       {
12025          {
12026             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12027             using T2 = IdentityMatrix<double,rowMajor>;
12028             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
12029             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12030 
12031             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12032             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12033             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12034          }
12035          {
12036             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12037             using T2 = IdentityMatrix<double,columnMajor>;
12038             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
12039             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12040 
12041             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12042             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12043             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12044          }
12045          {
12046             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12047             using T2 = IdentityMatrix<double,rowMajor>;
12048             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
12049             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12050 
12051             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12052             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12053             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12054          }
12055          {
12056             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12057             using T2 = IdentityMatrix<double,columnMajor>;
12058             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
12059             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12060 
12061             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12062             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12063             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12064          }
12065       }
12066 
12067       // .../ZeroMatrix
12068       {
12069          {
12070             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12071             using T2 = ZeroMatrix<double,rowMajor>;
12072             using RT = ZeroMatrix<double,rowMajor>;
12073             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12074 
12075             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12076             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12077             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12078          }
12079          {
12080             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12081             using T2 = ZeroMatrix<double,columnMajor>;
12082             using RT = ZeroMatrix<double,columnMajor>;
12083             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12084 
12085             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12086             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12087             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12088          }
12089          {
12090             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12091             using T2 = ZeroMatrix<double,rowMajor>;
12092             using RT = ZeroMatrix<double,rowMajor>;
12093             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12094 
12095             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12096             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12097             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12098          }
12099          {
12100             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12101             using T2 = ZeroMatrix<double,columnMajor>;
12102             using RT = ZeroMatrix<double,columnMajor>;
12103             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12104 
12105             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12106             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12107             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12108          }
12109       }
12110 
12111       // .../SymmetricMatrix<DynamicMatrix> (real)
12112       {
12113          {
12114             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12115             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12116             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12117             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12118 
12119             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12120             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12121             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12122          }
12123          {
12124             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12125             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12126             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12127             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12128 
12129             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12130             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12131             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12132          }
12133          {
12134             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12135             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12136             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12137             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12138 
12139             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12140             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12141             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12142          }
12143          {
12144             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12145             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12146             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12147             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12148 
12149             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12150             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12151             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12152          }
12153       }
12154 
12155       // .../SymmetricMatrix<DynamicMatrix> (complex)
12156       {
12157          {
12158             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12159             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12160             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12161             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12162 
12163             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12164             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12165             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12166          }
12167          {
12168             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12169             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12170             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12171             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12172 
12173             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12174             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12175             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12176          }
12177          {
12178             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12179             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12180             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12181             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12182 
12183             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12184             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12185             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12186          }
12187          {
12188             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12189             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12190             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12191             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12192 
12193             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12194             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12195             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12196          }
12197       }
12198 
12199       // .../SymmetricMatrix<UniformMatrix>
12200       {
12201          {
12202             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12203             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
12204             using RT = UniformMatrix<double,rowMajor>;
12205             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12206 
12207             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12208             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12209             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12210          }
12211          {
12212             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12213             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
12214             using RT = UniformMatrix<double,columnMajor>;
12215             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12216 
12217             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12218             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12219             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12220          }
12221          {
12222             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12223             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
12224             using RT = UniformMatrix<double,rowMajor>;
12225             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12226 
12227             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12228             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12229             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12230          }
12231          {
12232             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12233             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
12234             using RT = UniformMatrix<double,columnMajor>;
12235             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12236 
12237             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12238             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12239             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12240          }
12241       }
12242 
12243       // .../SymmetricMatrix<ZeroMatrix>
12244       {
12245          {
12246             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12247             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
12248             using RT = ZeroMatrix<double,rowMajor>;
12249             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12250 
12251             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12252             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12253             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12254          }
12255          {
12256             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12257             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
12258             using RT = ZeroMatrix<double,columnMajor>;
12259             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12260 
12261             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12262             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12263             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12264          }
12265          {
12266             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12267             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
12268             using RT = ZeroMatrix<double,rowMajor>;
12269             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12270 
12271             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12272             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12273             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12274          }
12275          {
12276             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12277             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
12278             using RT = ZeroMatrix<double,columnMajor>;
12279             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12280 
12281             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12282             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12283             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12284          }
12285       }
12286 
12287       // .../HermitianMatrix<DynamicMatrix> (symmetric)
12288       {
12289          {
12290             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12291             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
12292             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12293             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12294 
12295             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12296             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12297             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12298          }
12299          {
12300             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12301             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
12302             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12303             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12304 
12305             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12306             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12307             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12308          }
12309          {
12310             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12311             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
12312             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12313             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12314 
12315             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12316             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12317             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12318          }
12319          {
12320             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12321             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
12322             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12323             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12324 
12325             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12326             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12327             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12328          }
12329       }
12330 
12331       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
12332       {
12333          {
12334             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12335             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12336             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12337             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12338 
12339             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12340             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12341             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12342          }
12343          {
12344             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12345             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12346             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12347             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12348 
12349             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12350             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12351             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12352          }
12353          {
12354             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12355             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12356             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
12357             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12358 
12359             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12360             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12361             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12362          }
12363          {
12364             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12365             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12366             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
12367             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12368 
12369             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12370             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12371             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12372          }
12373       }
12374 
12375       // .../LowerMatrix<DynamicMatrix>
12376       {
12377          {
12378             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12379             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
12380             using RT = DynamicMatrix<double,rowMajor>;
12381             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12382 
12383             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12384             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12385             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12386          }
12387          {
12388             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12389             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
12390             using RT = DynamicMatrix<double,columnMajor>;
12391             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12392 
12393             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12394             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12395             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12396          }
12397          {
12398             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12399             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
12400             using RT = DynamicMatrix<double,rowMajor>;
12401             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12402 
12403             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12404             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12405             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12406          }
12407          {
12408             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12409             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
12410             using RT = DynamicMatrix<double,columnMajor>;
12411             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12412 
12413             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12414             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12415             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12416          }
12417       }
12418 
12419       // .../UniLowerMatrix<DynamicMatrix>
12420       {
12421          {
12422             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12423             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
12424             using RT = DynamicMatrix<double,rowMajor>;
12425             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12426 
12427             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12428             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12429             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12430          }
12431          {
12432             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12433             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
12434             using RT = DynamicMatrix<double,columnMajor>;
12435             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12436 
12437             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12438             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12439             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12440          }
12441          {
12442             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12443             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
12444             using RT = DynamicMatrix<double,rowMajor>;
12445             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12446 
12447             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12448             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12449             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12450          }
12451          {
12452             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12453             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
12454             using RT = DynamicMatrix<double,columnMajor>;
12455             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12456 
12457             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12458             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12459             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12460          }
12461       }
12462 
12463       // .../StrictlyLowerMatrix<DynamicMatrix>
12464       {
12465          {
12466             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12467             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
12468             using RT = DynamicMatrix<double,rowMajor>;
12469             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12470 
12471             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12472             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12473             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12474          }
12475          {
12476             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12477             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
12478             using RT = DynamicMatrix<double,columnMajor>;
12479             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12480 
12481             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12482             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12483             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12484          }
12485          {
12486             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12487             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
12488             using RT = DynamicMatrix<double,rowMajor>;
12489             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12490 
12491             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12492             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12493             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12494          }
12495          {
12496             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12497             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
12498             using RT = DynamicMatrix<double,columnMajor>;
12499             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12500 
12501             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12502             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12503             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12504          }
12505       }
12506 
12507       // .../UpperMatrix<DynamicMatrix>
12508       {
12509          {
12510             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12511             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
12512             using RT = DynamicMatrix<double,rowMajor>;
12513             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12514 
12515             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12516             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12517             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12518          }
12519          {
12520             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12521             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
12522             using RT = DynamicMatrix<double,columnMajor>;
12523             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12524 
12525             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12526             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12527             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12528          }
12529          {
12530             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12531             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
12532             using RT = DynamicMatrix<double,rowMajor>;
12533             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12534 
12535             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12536             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12537             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12538          }
12539          {
12540             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12541             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
12542             using RT = DynamicMatrix<double,columnMajor>;
12543             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12544 
12545             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12546             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12547             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12548          }
12549       }
12550 
12551       // .../UniUpperMatrix<DynamicMatrix>
12552       {
12553          {
12554             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12555             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
12556             using RT = DynamicMatrix<double,rowMajor>;
12557             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12558 
12559             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12560             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12561             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12562          }
12563          {
12564             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12565             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
12566             using RT = DynamicMatrix<double,columnMajor>;
12567             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12568 
12569             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12570             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12571             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12572          }
12573          {
12574             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12575             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
12576             using RT = DynamicMatrix<double,rowMajor>;
12577             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12578 
12579             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12580             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12581             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12582          }
12583          {
12584             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12585             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
12586             using RT = DynamicMatrix<double,columnMajor>;
12587             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12588 
12589             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12590             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12591             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12592          }
12593       }
12594 
12595       // .../StrictlyUpperMatrix<DynamicMatrix>
12596       {
12597          {
12598             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12599             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
12600             using RT = DynamicMatrix<double,rowMajor>;
12601             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12602 
12603             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12604             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12605             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12606          }
12607          {
12608             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12609             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
12610             using RT = DynamicMatrix<double,columnMajor>;
12611             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12612 
12613             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12614             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12615             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12616          }
12617          {
12618             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12619             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
12620             using RT = DynamicMatrix<double,rowMajor>;
12621             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12622 
12623             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12624             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12625             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12626          }
12627          {
12628             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12629             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
12630             using RT = DynamicMatrix<double,columnMajor>;
12631             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12632 
12633             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12634             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12635             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12636          }
12637       }
12638 
12639       // .../DiagonalMatrix<DynamicMatrix>
12640       {
12641          {
12642             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12643             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
12644             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12645             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12646 
12647             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12648             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12649             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12650          }
12651          {
12652             using T1 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
12653             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
12654             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12655             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12656 
12657             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12658             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12659             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12660          }
12661          {
12662             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12663             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
12664             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
12665             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12666 
12667             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12668             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12669             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12670          }
12671          {
12672             using T1 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
12673             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
12674             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
12675             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12676 
12677             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12678             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12679             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12680          }
12681       }
12682    }
12683 
12684    // SymmetricMatrix<ZeroMatrix>/...
12685    {
12686       // .../StaticMatrix
12687       {
12688          {
12689             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12690             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
12691             using RT = ZeroMatrix<double,rowMajor>;
12692             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12693 
12694             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12695             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12696             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12697          }
12698          {
12699             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12700             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
12701             using RT = ZeroMatrix<double,rowMajor>;
12702             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12703 
12704             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12705             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12706             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12707          }
12708          {
12709             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12710             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
12711             using RT = ZeroMatrix<double,columnMajor>;
12712             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12713 
12714             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12715             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12716             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12717          }
12718          {
12719             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12720             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
12721             using RT = ZeroMatrix<double,columnMajor>;
12722             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12723 
12724             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12725             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12726             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12727          }
12728       }
12729 
12730       // .../HybridMatrix
12731       {
12732          {
12733             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12734             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
12735             using RT = ZeroMatrix<double,rowMajor>;
12736             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12737 
12738             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12739             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12740             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12741          }
12742          {
12743             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12744             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
12745             using RT = ZeroMatrix<double,rowMajor>;
12746             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12747 
12748             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12749             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12750             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12751          }
12752          {
12753             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12754             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
12755             using RT = ZeroMatrix<double,columnMajor>;
12756             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12757 
12758             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12759             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12760             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12761          }
12762          {
12763             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12764             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
12765             using RT = ZeroMatrix<double,columnMajor>;
12766             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12767 
12768             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12769             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12770             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12771          }
12772       }
12773 
12774       // .../DynamicMatrix
12775       {
12776          {
12777             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12778             using T2 = DynamicMatrix<double,rowMajor>;
12779             using RT = ZeroMatrix<double,rowMajor>;
12780             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12781 
12782             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12783             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12784             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12785          }
12786          {
12787             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12788             using T2 = DynamicMatrix<double,columnMajor>;
12789             using RT = ZeroMatrix<double,rowMajor>;
12790             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12791 
12792             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12793             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12794             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12795          }
12796          {
12797             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12798             using T2 = DynamicMatrix<double,rowMajor>;
12799             using RT = ZeroMatrix<double,columnMajor>;
12800             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12801 
12802             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12803             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12804             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12805          }
12806          {
12807             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12808             using T2 = DynamicMatrix<double,columnMajor>;
12809             using RT = ZeroMatrix<double,columnMajor>;
12810             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12811 
12812             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12813             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12814             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12815          }
12816       }
12817 
12818       // .../CustomMatrix
12819       {
12820          {
12821             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12822             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
12823             using RT = ZeroMatrix<double,rowMajor>;
12824             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12825 
12826             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12827             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12828             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12829          }
12830          {
12831             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12832             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
12833             using RT = ZeroMatrix<double,rowMajor>;
12834             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12835 
12836             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12837             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12838             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12839          }
12840          {
12841             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12842             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
12843             using RT = ZeroMatrix<double,columnMajor>;
12844             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12845 
12846             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12847             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12848             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12849          }
12850          {
12851             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12852             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
12853             using RT = ZeroMatrix<double,columnMajor>;
12854             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12855 
12856             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12857             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12858             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12859          }
12860       }
12861 
12862       // .../UniformMatrix
12863       {
12864          {
12865             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12866             using T2 = UniformMatrix<double,rowMajor>;
12867             using RT = ZeroMatrix<double,rowMajor>;
12868             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12869 
12870             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12871             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12872             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12873          }
12874          {
12875             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12876             using T2 = UniformMatrix<double,columnMajor>;
12877             using RT = ZeroMatrix<double,rowMajor>;
12878             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12879 
12880             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12881             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12882             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12883          }
12884          {
12885             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12886             using T2 = UniformMatrix<double,rowMajor>;
12887             using RT = ZeroMatrix<double,columnMajor>;
12888             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12889 
12890             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12891             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12892             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12893          }
12894          {
12895             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12896             using T2 = UniformMatrix<double,columnMajor>;
12897             using RT = ZeroMatrix<double,columnMajor>;
12898             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12899 
12900             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12901             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12902             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12903          }
12904       }
12905 
12906       // .../InitializerMatrix
12907       {
12908          {
12909             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12910             using T2 = InitializerMatrix<double>;
12911             using RT = ZeroMatrix<double,rowMajor>;
12912             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12913 
12914             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12915             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12916             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12917          }
12918          {
12919             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12920             using T2 = InitializerMatrix<double>;
12921             using RT = ZeroMatrix<double,columnMajor>;
12922             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12923 
12924             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12925             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12926             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12927          }
12928       }
12929 
12930       // .../CompressedMatrix
12931       {
12932          {
12933             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12934             using T2 = CompressedMatrix<double,rowMajor>;
12935             using RT = ZeroMatrix<double,rowMajor>;
12936             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12937 
12938             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12939             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12940             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12941          }
12942          {
12943             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12944             using T2 = CompressedMatrix<double,columnMajor>;
12945             using RT = ZeroMatrix<double,rowMajor>;
12946             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12947 
12948             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12949             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12950             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12951          }
12952          {
12953             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12954             using T2 = CompressedMatrix<double,rowMajor>;
12955             using RT = ZeroMatrix<double,columnMajor>;
12956             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12957 
12958             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12959             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12960             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12961          }
12962          {
12963             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12964             using T2 = CompressedMatrix<double,columnMajor>;
12965             using RT = ZeroMatrix<double,columnMajor>;
12966             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12967 
12968             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12969             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12970             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12971          }
12972       }
12973 
12974       // .../IdentityMatrix
12975       {
12976          {
12977             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12978             using T2 = IdentityMatrix<double,rowMajor>;
12979             using RT = ZeroMatrix<double,rowMajor>;
12980             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12981 
12982             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12983             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12984             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12985          }
12986          {
12987             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
12988             using T2 = IdentityMatrix<double,columnMajor>;
12989             using RT = ZeroMatrix<double,rowMajor>;
12990             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
12991 
12992             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
12993             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
12994             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
12995          }
12996          {
12997             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
12998             using T2 = IdentityMatrix<double,rowMajor>;
12999             using RT = ZeroMatrix<double,columnMajor>;
13000             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13001 
13002             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13003             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13004             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13005          }
13006          {
13007             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13008             using T2 = IdentityMatrix<double,columnMajor>;
13009             using RT = ZeroMatrix<double,columnMajor>;
13010             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13011 
13012             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13013             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13014             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13015          }
13016       }
13017 
13018       // .../ZeroMatrix
13019       {
13020          {
13021             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13022             using T2 = ZeroMatrix<double,rowMajor>;
13023             using RT = ZeroMatrix<double,rowMajor>;
13024             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13025 
13026             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13027             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13028             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13029          }
13030          {
13031             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13032             using T2 = ZeroMatrix<double,columnMajor>;
13033             using RT = ZeroMatrix<double,columnMajor>;
13034             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13035 
13036             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13037             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13038             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13039          }
13040          {
13041             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13042             using T2 = ZeroMatrix<double,rowMajor>;
13043             using RT = ZeroMatrix<double,rowMajor>;
13044             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13045 
13046             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13047             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13048             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13049          }
13050          {
13051             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13052             using T2 = ZeroMatrix<double,columnMajor>;
13053             using RT = ZeroMatrix<double,columnMajor>;
13054             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13055 
13056             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13057             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13058             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13059          }
13060       }
13061 
13062       // .../SymmetricMatrix<DynamicMatrix> (real)
13063       {
13064          {
13065             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13066             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
13067             using RT = ZeroMatrix<double,rowMajor>;
13068             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13069 
13070             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13071             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13072             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13073          }
13074          {
13075             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13076             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
13077             using RT = ZeroMatrix<double,rowMajor>;
13078             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13079 
13080             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13081             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13082             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13083          }
13084          {
13085             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13086             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
13087             using RT = ZeroMatrix<double,columnMajor>;
13088             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13089 
13090             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13091             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13092             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13093          }
13094          {
13095             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13096             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
13097             using RT = ZeroMatrix<double,columnMajor>;
13098             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13099 
13100             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13101             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13102             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13103          }
13104       }
13105 
13106       // .../SymmetricMatrix<DynamicMatrix> (complex)
13107       {
13108          {
13109             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13110             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
13111             using RT = ZeroMatrix<complex<int>,rowMajor>;
13112             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13113 
13114             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13115             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13116             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13117          }
13118          {
13119             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13120             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
13121             using RT = ZeroMatrix<complex<int>,rowMajor>;
13122             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13123 
13124             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13125             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13126             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13127          }
13128          {
13129             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13130             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
13131             using RT = ZeroMatrix<complex<int>,columnMajor>;
13132             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13133 
13134             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13135             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13136             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13137          }
13138          {
13139             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13140             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
13141             using RT = ZeroMatrix<complex<int>,columnMajor>;
13142             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13143 
13144             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13145             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13146             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13147          }
13148       }
13149 
13150       // .../SymmetricMatrix<UniformMatrix>
13151       {
13152          {
13153             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13154             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
13155             using RT = ZeroMatrix<double,rowMajor>;
13156             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13157 
13158             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13159             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13160             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13161          }
13162          {
13163             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13164             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
13165             using RT = ZeroMatrix<double,rowMajor>;
13166             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13167 
13168             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13169             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13170             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13171          }
13172          {
13173             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13174             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
13175             using RT = ZeroMatrix<double,columnMajor>;
13176             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13177 
13178             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13179             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13180             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13181          }
13182          {
13183             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13184             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
13185             using RT = ZeroMatrix<double,columnMajor>;
13186             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13187 
13188             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13189             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13190             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13191          }
13192       }
13193 
13194       // .../SymmetricMatrix<ZeroMatrix>
13195       {
13196          {
13197             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13198             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
13199             using RT = ZeroMatrix<double,rowMajor>;
13200             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13201 
13202             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13203             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13204             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13205          }
13206          {
13207             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13208             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
13209             using RT = ZeroMatrix<double,columnMajor>;
13210             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13211 
13212             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13213             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13214             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13215          }
13216          {
13217             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13218             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
13219             using RT = ZeroMatrix<double,rowMajor>;
13220             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13221 
13222             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13223             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13224             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13225          }
13226          {
13227             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13228             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
13229             using RT = ZeroMatrix<double,columnMajor>;
13230             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13231 
13232             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13233             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13234             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13235          }
13236       }
13237 
13238       // .../HermitianMatrix<DynamicMatrix> (symmetric)
13239       {
13240          {
13241             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13242             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
13243             using RT = ZeroMatrix<double,rowMajor>;
13244             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13245 
13246             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13247             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13248             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13249          }
13250          {
13251             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13252             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
13253             using RT = ZeroMatrix<double,rowMajor>;
13254             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13255 
13256             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13257             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13258             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13259          }
13260          {
13261             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13262             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
13263             using RT = ZeroMatrix<double,columnMajor>;
13264             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13265 
13266             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13267             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13268             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13269          }
13270          {
13271             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13272             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
13273             using RT = ZeroMatrix<double,columnMajor>;
13274             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13275 
13276             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13277             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13278             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13279          }
13280       }
13281 
13282       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
13283       {
13284          {
13285             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13286             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
13287             using RT = ZeroMatrix<complex<int>,rowMajor>;
13288             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13289 
13290             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13291             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13292             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13293          }
13294          {
13295             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13296             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
13297             using RT = ZeroMatrix<complex<int>,rowMajor>;
13298             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13299 
13300             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13301             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13302             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13303          }
13304          {
13305             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13306             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
13307             using RT = ZeroMatrix<complex<int>,columnMajor>;
13308             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13309 
13310             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13311             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13312             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13313          }
13314          {
13315             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13316             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
13317             using RT = ZeroMatrix<complex<int>,columnMajor>;
13318             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13319 
13320             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13321             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13322             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13323          }
13324       }
13325 
13326       // .../LowerMatrix<DynamicMatrix>
13327       {
13328          {
13329             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13330             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
13331             using RT = ZeroMatrix<double,rowMajor>;
13332             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13333 
13334             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13335             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13336             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13337          }
13338          {
13339             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13340             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
13341             using RT = ZeroMatrix<double,rowMajor>;
13342             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13343 
13344             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13345             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13346             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13347          }
13348          {
13349             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13350             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
13351             using RT = ZeroMatrix<double,columnMajor>;
13352             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13353 
13354             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13355             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13356             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13357          }
13358          {
13359             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13360             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
13361             using RT = ZeroMatrix<double,columnMajor>;
13362             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13363 
13364             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13365             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13366             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13367          }
13368       }
13369 
13370       // .../UniLowerMatrix<DynamicMatrix>
13371       {
13372          {
13373             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13374             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
13375             using RT = ZeroMatrix<double,rowMajor>;
13376             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13377 
13378             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13379             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13380             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13381          }
13382          {
13383             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13384             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
13385             using RT = ZeroMatrix<double,rowMajor>;
13386             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13387 
13388             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13389             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13390             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13391          }
13392          {
13393             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13394             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
13395             using RT = ZeroMatrix<double,columnMajor>;
13396             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13397 
13398             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13399             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13400             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13401          }
13402          {
13403             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13404             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
13405             using RT = ZeroMatrix<double,columnMajor>;
13406             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13407 
13408             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13409             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13410             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13411          }
13412       }
13413 
13414       // .../StrictlyLowerMatrix<DynamicMatrix>
13415       {
13416          {
13417             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13418             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
13419             using RT = ZeroMatrix<double,rowMajor>;
13420             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13421 
13422             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13423             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13424             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13425          }
13426          {
13427             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13428             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
13429             using RT = ZeroMatrix<double,rowMajor>;
13430             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13431 
13432             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13433             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13434             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13435          }
13436          {
13437             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13438             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
13439             using RT = ZeroMatrix<double,columnMajor>;
13440             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13441 
13442             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13443             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13444             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13445          }
13446          {
13447             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13448             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
13449             using RT = ZeroMatrix<double,columnMajor>;
13450             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13451 
13452             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13453             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13454             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13455          }
13456       }
13457 
13458       // .../UpperMatrix<DynamicMatrix>
13459       {
13460          {
13461             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13462             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
13463             using RT = ZeroMatrix<double,rowMajor>;
13464             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13465 
13466             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13467             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13468             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13469          }
13470          {
13471             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13472             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
13473             using RT = ZeroMatrix<double,rowMajor>;
13474             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13475 
13476             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13477             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13478             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13479          }
13480          {
13481             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13482             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
13483             using RT = ZeroMatrix<double,columnMajor>;
13484             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13485 
13486             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13487             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13488             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13489          }
13490          {
13491             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13492             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
13493             using RT = ZeroMatrix<double,columnMajor>;
13494             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13495 
13496             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13497             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13498             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13499          }
13500       }
13501 
13502       // .../UniUpperMatrix<DynamicMatrix>
13503       {
13504          {
13505             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13506             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
13507             using RT = ZeroMatrix<double,rowMajor>;
13508             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13509 
13510             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13511             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13512             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13513          }
13514          {
13515             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13516             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
13517             using RT = ZeroMatrix<double,rowMajor>;
13518             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13519 
13520             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13521             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13522             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13523          }
13524          {
13525             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13526             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
13527             using RT = ZeroMatrix<double,columnMajor>;
13528             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13529 
13530             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13531             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13532             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13533          }
13534          {
13535             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13536             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
13537             using RT = ZeroMatrix<double,columnMajor>;
13538             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13539 
13540             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13541             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13542             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13543          }
13544       }
13545 
13546       // .../StrictlyUpperMatrix<DynamicMatrix>
13547       {
13548          {
13549             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13550             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
13551             using RT = ZeroMatrix<double,rowMajor>;
13552             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13553 
13554             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13555             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13556             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13557          }
13558          {
13559             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13560             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
13561             using RT = ZeroMatrix<double,rowMajor>;
13562             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13563 
13564             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13565             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13566             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13567          }
13568          {
13569             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13570             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
13571             using RT = ZeroMatrix<double,columnMajor>;
13572             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13573 
13574             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13575             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13576             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13577          }
13578          {
13579             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13580             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
13581             using RT = ZeroMatrix<double,columnMajor>;
13582             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13583 
13584             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13585             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13586             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13587          }
13588       }
13589 
13590       // .../DiagonalMatrix<DynamicMatrix>
13591       {
13592          {
13593             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13594             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
13595             using RT = ZeroMatrix<double,rowMajor>;
13596             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13597 
13598             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13599             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13600             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13601          }
13602          {
13603             using T1 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
13604             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
13605             using RT = ZeroMatrix<double,rowMajor>;
13606             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13607 
13608             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13609             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13610             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13611          }
13612          {
13613             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13614             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
13615             using RT = ZeroMatrix<double,columnMajor>;
13616             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13617 
13618             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13619             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13620             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13621          }
13622          {
13623             using T1 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
13624             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
13625             using RT = ZeroMatrix<double,columnMajor>;
13626             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13627 
13628             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13629             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13630             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13631          }
13632       }
13633    }
13634 
13635    // HermitianMatrix<DynamicMatrix>/... (symmetric)
13636    {
13637       // .../StaticMatrix
13638       {
13639          {
13640             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13641             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
13642             using RT = DynamicMatrix<double,rowMajor>;
13643             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13644 
13645             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13646             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13647             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13648          }
13649          {
13650             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13651             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
13652             using RT = DynamicMatrix<double,columnMajor>;
13653             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13654 
13655             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13656             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13657             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13658          }
13659          {
13660             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13661             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
13662             using RT = DynamicMatrix<double,rowMajor>;
13663             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13664 
13665             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13666             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13667             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13668          }
13669          {
13670             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13671             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
13672             using RT = DynamicMatrix<double,columnMajor>;
13673             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13674 
13675             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13676             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13677             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13678          }
13679       }
13680 
13681       // .../HybridMatrix
13682       {
13683          {
13684             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13685             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
13686             using RT = DynamicMatrix<double,rowMajor>;
13687             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13688 
13689             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13690             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13691             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13692          }
13693          {
13694             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13695             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
13696             using RT = DynamicMatrix<double,columnMajor>;
13697             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13698 
13699             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13700             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13701             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13702          }
13703          {
13704             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13705             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
13706             using RT = DynamicMatrix<double,rowMajor>;
13707             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13708 
13709             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13710             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13711             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13712          }
13713          {
13714             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13715             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
13716             using RT = DynamicMatrix<double,columnMajor>;
13717             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13718 
13719             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13720             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13721             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13722          }
13723       }
13724 
13725       // .../DynamicMatrix
13726       {
13727          {
13728             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13729             using T2 = DynamicMatrix<double,rowMajor>;
13730             using RT = DynamicMatrix<double,rowMajor>;
13731             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13732 
13733             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13734             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13735             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13736          }
13737          {
13738             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13739             using T2 = DynamicMatrix<double,columnMajor>;
13740             using RT = DynamicMatrix<double,columnMajor>;
13741             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13742 
13743             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13744             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13745             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13746          }
13747          {
13748             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13749             using T2 = DynamicMatrix<double,rowMajor>;
13750             using RT = DynamicMatrix<double,rowMajor>;
13751             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13752 
13753             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13754             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13755             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13756          }
13757          {
13758             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13759             using T2 = DynamicMatrix<double,columnMajor>;
13760             using RT = DynamicMatrix<double,columnMajor>;
13761             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13762 
13763             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13764             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13765             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13766          }
13767       }
13768 
13769       // .../CustomMatrix
13770       {
13771          {
13772             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13773             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
13774             using RT = DynamicMatrix<double,rowMajor>;
13775             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13776 
13777             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13778             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13779             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13780          }
13781          {
13782             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13783             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
13784             using RT = DynamicMatrix<double,columnMajor>;
13785             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13786 
13787             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13788             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13789             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13790          }
13791          {
13792             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13793             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
13794             using RT = DynamicMatrix<double,rowMajor>;
13795             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13796 
13797             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13798             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13799             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13800          }
13801          {
13802             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13803             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
13804             using RT = DynamicMatrix<double,columnMajor>;
13805             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13806 
13807             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13808             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13809             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13810          }
13811       }
13812 
13813       // .../UniformMatrix
13814       {
13815          {
13816             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13817             using T2 = UniformMatrix<double,rowMajor>;
13818             using RT = DynamicMatrix<double,rowMajor>;
13819             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13820 
13821             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13822             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13823             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13824          }
13825          {
13826             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13827             using T2 = UniformMatrix<double,columnMajor>;
13828             using RT = DynamicMatrix<double,columnMajor>;
13829             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13830 
13831             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13832             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13833             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13834          }
13835          {
13836             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13837             using T2 = UniformMatrix<double,rowMajor>;
13838             using RT = DynamicMatrix<double,rowMajor>;
13839             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13840 
13841             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13842             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13843             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13844          }
13845          {
13846             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13847             using T2 = UniformMatrix<double,columnMajor>;
13848             using RT = DynamicMatrix<double,columnMajor>;
13849             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13850 
13851             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13852             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13853             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13854          }
13855       }
13856 
13857       // .../InitializerMatrix
13858       {
13859          {
13860             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13861             using T2 = InitializerMatrix<double>;
13862             using RT = DynamicMatrix<double,rowMajor>;
13863             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13864 
13865             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13866             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13867             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13868          }
13869          {
13870             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13871             using T2 = InitializerMatrix<double>;
13872             using RT = DynamicMatrix<double,rowMajor>;
13873             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13874 
13875             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13876             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13877             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13878          }
13879       }
13880 
13881       // .../CompressedMatrix
13882       {
13883          {
13884             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13885             using T2 = CompressedMatrix<double,rowMajor>;
13886             using RT = CompressedMatrix<double,rowMajor>;
13887             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13888 
13889             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13890             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13891             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13892          }
13893          {
13894             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13895             using T2 = CompressedMatrix<double,columnMajor>;
13896             using RT = CompressedMatrix<double,columnMajor>;
13897             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13898 
13899             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13900             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13901             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13902          }
13903          {
13904             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13905             using T2 = CompressedMatrix<double,rowMajor>;
13906             using RT = CompressedMatrix<double,rowMajor>;
13907             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13908 
13909             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13910             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13911             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13912          }
13913          {
13914             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13915             using T2 = CompressedMatrix<double,columnMajor>;
13916             using RT = CompressedMatrix<double,columnMajor>;
13917             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13918 
13919             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13920             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13921             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13922          }
13923       }
13924 
13925       // .../IdentityMatrix
13926       {
13927          {
13928             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13929             using T2 = IdentityMatrix<double,rowMajor>;
13930             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
13931             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13932 
13933             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13934             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13935             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13936          }
13937          {
13938             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13939             using T2 = IdentityMatrix<double,columnMajor>;
13940             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
13941             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13942 
13943             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13944             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13945             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13946          }
13947          {
13948             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13949             using T2 = IdentityMatrix<double,rowMajor>;
13950             using RT = SymmetricMatrix< CompressedMatrix<double,rowMajor> >;
13951             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13952 
13953             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13954             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13955             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13956          }
13957          {
13958             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13959             using T2 = IdentityMatrix<double,columnMajor>;
13960             using RT = SymmetricMatrix< CompressedMatrix<double,columnMajor> >;
13961             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13962 
13963             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13964             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13965             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13966          }
13967       }
13968 
13969       // .../ZeroMatrix
13970       {
13971          {
13972             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13973             using T2 = ZeroMatrix<double,rowMajor>;
13974             using RT = ZeroMatrix<double,rowMajor>;
13975             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13976 
13977             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13978             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13979             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13980          }
13981          {
13982             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
13983             using T2 = ZeroMatrix<double,columnMajor>;
13984             using RT = ZeroMatrix<double,columnMajor>;
13985             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13986 
13987             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13988             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13989             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
13990          }
13991          {
13992             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
13993             using T2 = ZeroMatrix<double,rowMajor>;
13994             using RT = ZeroMatrix<double,rowMajor>;
13995             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
13996 
13997             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
13998             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
13999             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14000          }
14001          {
14002             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14003             using T2 = ZeroMatrix<double,columnMajor>;
14004             using RT = ZeroMatrix<double,columnMajor>;
14005             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14006 
14007             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14008             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14009             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14010          }
14011       }
14012 
14013       // .../SymmetricMatrix<DynamicMatrix> (real)
14014       {
14015          {
14016             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14017             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14018             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14019             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14020 
14021             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14022             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14023             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14024          }
14025          {
14026             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14027             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14028             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14029             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14030 
14031             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14032             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14033             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14034          }
14035          {
14036             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14037             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14038             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14039             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14040 
14041             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14042             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14043             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14044          }
14045          {
14046             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14047             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14048             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14049             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14050 
14051             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14052             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14053             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14054          }
14055       }
14056 
14057       // .../SymmetricMatrix<DynamicMatrix> (complex)
14058       {
14059          {
14060             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14061             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14062             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14063             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14064 
14065             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14066             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14067             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14068          }
14069          {
14070             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14071             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14072             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14073             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14074 
14075             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14076             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14077             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14078          }
14079          {
14080             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14081             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14082             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14083             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14084 
14085             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14086             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14087             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14088          }
14089          {
14090             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14091             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14092             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14093             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14094 
14095             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14096             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14097             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14098          }
14099       }
14100 
14101       // .../SymmetricMatrix<UniformMatrix>
14102       {
14103          {
14104             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14105             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
14106             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14107             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14108 
14109             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14110             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14111             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14112          }
14113          {
14114             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14115             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
14116             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14117             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14118 
14119             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14120             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14121             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14122          }
14123          {
14124             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14125             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
14126             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14127             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14128 
14129             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14130             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14131             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14132          }
14133          {
14134             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14135             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
14136             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14137             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14138 
14139             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14140             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14141             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14142          }
14143       }
14144 
14145       // .../SymmetricMatrix<ZeroMatrix>
14146       {
14147          {
14148             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14149             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
14150             using RT = ZeroMatrix<double,rowMajor>;
14151             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14152 
14153             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14154             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14155             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14156          }
14157          {
14158             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14159             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
14160             using RT = ZeroMatrix<double,columnMajor>;
14161             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14162 
14163             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14164             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14165             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14166          }
14167          {
14168             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14169             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
14170             using RT = ZeroMatrix<double,rowMajor>;
14171             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14172 
14173             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14174             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14175             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14176          }
14177          {
14178             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14179             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
14180             using RT = ZeroMatrix<double,columnMajor>;
14181             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14182 
14183             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14184             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14185             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14186          }
14187       }
14188 
14189       // .../HermitianMatrix<DynamicMatrix> (symmetric)
14190       {
14191          {
14192             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14193             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
14194             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14195             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14196 
14197             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14198             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14199             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14200          }
14201          {
14202             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14203             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
14204             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14205             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14206 
14207             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14208             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14209             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14210          }
14211          {
14212             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14213             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
14214             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14215             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14216 
14217             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14218             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14219             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14220          }
14221          {
14222             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14223             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
14224             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14225             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14226 
14227             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14228             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14229             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14230          }
14231       }
14232 
14233       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
14234       {
14235          {
14236             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14237             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14238             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14239             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14240 
14241             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14242             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14243             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14244          }
14245          {
14246             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14247             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14248             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14249             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14250 
14251             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14252             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14253             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14254          }
14255          {
14256             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14257             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14258             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14259             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14260 
14261             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14262             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14263             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14264          }
14265          {
14266             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14267             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14268             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14269             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14270 
14271             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14272             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14273             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14274          }
14275       }
14276 
14277       // .../LowerMatrix<DynamicMatrix>
14278       {
14279          {
14280             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14281             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
14282             using RT = DynamicMatrix<double,rowMajor>;
14283             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14284 
14285             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14286             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14287             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14288          }
14289          {
14290             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14291             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
14292             using RT = DynamicMatrix<double,columnMajor>;
14293             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14294 
14295             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14296             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14297             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14298          }
14299          {
14300             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14301             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
14302             using RT = DynamicMatrix<double,rowMajor>;
14303             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14304 
14305             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14306             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14307             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14308          }
14309          {
14310             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14311             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
14312             using RT = DynamicMatrix<double,columnMajor>;
14313             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14314 
14315             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14316             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14317             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14318          }
14319       }
14320 
14321       // .../UniLowerMatrix<DynamicMatrix>
14322       {
14323          {
14324             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14325             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
14326             using RT = DynamicMatrix<double,rowMajor>;
14327             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14328 
14329             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14330             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14331             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14332          }
14333          {
14334             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14335             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
14336             using RT = DynamicMatrix<double,columnMajor>;
14337             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14338 
14339             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14340             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14341             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14342          }
14343          {
14344             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14345             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
14346             using RT = DynamicMatrix<double,rowMajor>;
14347             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14348 
14349             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14350             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14351             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14352          }
14353          {
14354             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14355             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
14356             using RT = DynamicMatrix<double,columnMajor>;
14357             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14358 
14359             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14360             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14361             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14362          }
14363       }
14364 
14365       // .../StrictlyLowerMatrix<DynamicMatrix>
14366       {
14367          {
14368             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14369             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
14370             using RT = DynamicMatrix<double,rowMajor>;
14371             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14372 
14373             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14374             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14375             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14376          }
14377          {
14378             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14379             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
14380             using RT = DynamicMatrix<double,columnMajor>;
14381             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14382 
14383             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14384             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14385             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14386          }
14387          {
14388             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14389             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
14390             using RT = DynamicMatrix<double,rowMajor>;
14391             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14392 
14393             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14394             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14395             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14396          }
14397          {
14398             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14399             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
14400             using RT = DynamicMatrix<double,columnMajor>;
14401             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14402 
14403             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14404             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14405             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14406          }
14407       }
14408 
14409       // .../UpperMatrix<DynamicMatrix>
14410       {
14411          {
14412             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14413             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
14414             using RT = DynamicMatrix<double,rowMajor>;
14415             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14416 
14417             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14418             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14419             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14420          }
14421          {
14422             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14423             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
14424             using RT = DynamicMatrix<double,columnMajor>;
14425             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14426 
14427             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14428             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14429             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14430          }
14431          {
14432             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14433             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
14434             using RT = DynamicMatrix<double,rowMajor>;
14435             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14436 
14437             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14438             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14439             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14440          }
14441          {
14442             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14443             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
14444             using RT = DynamicMatrix<double,columnMajor>;
14445             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14446 
14447             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14448             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14449             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14450          }
14451       }
14452 
14453       // .../UniUpperMatrix<DynamicMatrix>
14454       {
14455          {
14456             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14457             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
14458             using RT = DynamicMatrix<double,rowMajor>;
14459             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14460 
14461             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14462             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14463             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14464          }
14465          {
14466             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14467             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
14468             using RT = DynamicMatrix<double,columnMajor>;
14469             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14470 
14471             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14472             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14473             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14474          }
14475          {
14476             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14477             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
14478             using RT = DynamicMatrix<double,rowMajor>;
14479             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14480 
14481             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14482             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14483             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14484          }
14485          {
14486             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14487             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
14488             using RT = DynamicMatrix<double,columnMajor>;
14489             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14490 
14491             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14492             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14493             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14494          }
14495       }
14496 
14497       // .../StrictlyUpperMatrix<DynamicMatrix>
14498       {
14499          {
14500             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14501             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
14502             using RT = DynamicMatrix<double,rowMajor>;
14503             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14504 
14505             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14506             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14507             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14508          }
14509          {
14510             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14511             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
14512             using RT = DynamicMatrix<double,columnMajor>;
14513             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14514 
14515             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14516             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14517             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14518          }
14519          {
14520             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14521             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
14522             using RT = DynamicMatrix<double,rowMajor>;
14523             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14524 
14525             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14526             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14527             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14528          }
14529          {
14530             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14531             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
14532             using RT = DynamicMatrix<double,columnMajor>;
14533             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14534 
14535             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14536             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14537             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14538          }
14539       }
14540 
14541       // .../DiagonalMatrix<DynamicMatrix>
14542       {
14543          {
14544             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14545             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
14546             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14547             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14548 
14549             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14550             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14551             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14552          }
14553          {
14554             using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
14555             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
14556             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14557             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14558 
14559             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14560             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14561             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14562          }
14563          {
14564             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14565             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
14566             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
14567             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14568 
14569             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14570             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14571             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14572          }
14573          {
14574             using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
14575             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
14576             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
14577             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14578 
14579             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14580             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14581             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14582          }
14583       }
14584    }
14585 
14586    // HermitianMatrix<DynamicMatrix>/... (Hermitian)
14587    {
14588       // .../StaticMatrix
14589       {
14590          {
14591             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14592             using T2 = StaticMatrix<int,3UL,3UL,rowMajor>;
14593             using RT = DynamicMatrix<complex<int>,rowMajor>;
14594             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14595 
14596             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14597             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14598             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14599          }
14600          {
14601             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14602             using T2 = StaticMatrix<int,3UL,3UL,columnMajor>;
14603             using RT = DynamicMatrix<complex<int>,columnMajor>;
14604             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14605 
14606             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14607             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14608             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14609          }
14610          {
14611             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14612             using T2 = StaticMatrix<int,3UL,3UL,rowMajor>;
14613             using RT = DynamicMatrix<complex<int>,rowMajor>;
14614             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14615 
14616             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14617             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14618             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14619          }
14620          {
14621             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14622             using T2 = StaticMatrix<int,3UL,3UL,columnMajor>;
14623             using RT = DynamicMatrix<complex<int>,columnMajor>;
14624             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14625 
14626             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14627             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14628             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14629          }
14630       }
14631 
14632       // .../HybridMatrix
14633       {
14634          {
14635             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14636             using T2 = HybridMatrix<int,8UL,6UL,rowMajor>;
14637             using RT = DynamicMatrix<complex<int>,rowMajor>;
14638             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14639 
14640             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14641             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14642             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14643          }
14644          {
14645             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14646             using T2 = HybridMatrix<int,8UL,6UL,columnMajor>;
14647             using RT = DynamicMatrix<complex<int>,columnMajor>;
14648             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14649 
14650             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14651             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14652             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14653          }
14654          {
14655             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14656             using T2 = HybridMatrix<int,8UL,6UL,rowMajor>;
14657             using RT = DynamicMatrix<complex<int>,rowMajor>;
14658             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14659 
14660             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14661             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14662             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14663          }
14664          {
14665             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14666             using T2 = HybridMatrix<int,8UL,6UL,columnMajor>;
14667             using RT = DynamicMatrix<complex<int>,columnMajor>;
14668             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14669 
14670             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14671             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14672             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14673          }
14674       }
14675 
14676       // .../DynamicMatrix
14677       {
14678          {
14679             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14680             using T2 = DynamicMatrix<int,rowMajor>;
14681             using RT = DynamicMatrix<complex<int>,rowMajor>;
14682             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14683 
14684             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14685             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14686             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14687          }
14688          {
14689             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14690             using T2 = DynamicMatrix<int,columnMajor>;
14691             using RT = DynamicMatrix<complex<int>,columnMajor>;
14692             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14693 
14694             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14695             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14696             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14697          }
14698          {
14699             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14700             using T2 = DynamicMatrix<int,rowMajor>;
14701             using RT = DynamicMatrix<complex<int>,rowMajor>;
14702             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14703 
14704             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14705             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14706             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14707          }
14708          {
14709             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14710             using T2 = DynamicMatrix<int,columnMajor>;
14711             using RT = DynamicMatrix<complex<int>,columnMajor>;
14712             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14713 
14714             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14715             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14716             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14717          }
14718       }
14719 
14720       // .../CustomMatrix
14721       {
14722          {
14723             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14724             using T2 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
14725             using RT = DynamicMatrix<complex<int>,rowMajor>;
14726             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14727 
14728             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14729             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14730             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14731          }
14732          {
14733             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14734             using T2 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
14735             using RT = DynamicMatrix<complex<int>,columnMajor>;
14736             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14737 
14738             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14739             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14740             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14741          }
14742          {
14743             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14744             using T2 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
14745             using RT = DynamicMatrix<complex<int>,rowMajor>;
14746             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14747 
14748             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14749             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14750             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14751          }
14752          {
14753             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14754             using T2 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
14755             using RT = DynamicMatrix<complex<int>,columnMajor>;
14756             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14757 
14758             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14759             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14760             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14761          }
14762       }
14763 
14764       // .../UniformMatrix
14765       {
14766          {
14767             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14768             using T2 = UniformMatrix<int,rowMajor>;
14769             using RT = DynamicMatrix<complex<int>,rowMajor>;
14770             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14771 
14772             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14773             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14774             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14775          }
14776          {
14777             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14778             using T2 = UniformMatrix<int,columnMajor>;
14779             using RT = DynamicMatrix<complex<int>,columnMajor>;
14780             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14781 
14782             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14783             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14784             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14785          }
14786          {
14787             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14788             using T2 = UniformMatrix<int,rowMajor>;
14789             using RT = DynamicMatrix<complex<int>,rowMajor>;
14790             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14791 
14792             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14793             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14794             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14795          }
14796          {
14797             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14798             using T2 = UniformMatrix<int,columnMajor>;
14799             using RT = DynamicMatrix<complex<int>,columnMajor>;
14800             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14801 
14802             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14803             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14804             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14805          }
14806       }
14807 
14808       // .../InitializerMatrix
14809       {
14810          {
14811             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14812             using T2 = InitializerMatrix<int>;
14813             using RT = DynamicMatrix<complex<int>,rowMajor>;
14814             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14815 
14816             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14817             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14818             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14819          }
14820          {
14821             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14822             using T2 = InitializerMatrix<int>;
14823             using RT = DynamicMatrix<complex<int>,rowMajor>;
14824             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14825 
14826             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14827             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14828             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14829          }
14830       }
14831 
14832       // .../CompressedMatrix
14833       {
14834          {
14835             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14836             using T2 = CompressedMatrix<int,rowMajor>;
14837             using RT = CompressedMatrix<complex<int>,rowMajor>;
14838             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14839 
14840             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14841             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14842             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14843          }
14844          {
14845             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14846             using T2 = CompressedMatrix<int,columnMajor>;
14847             using RT = CompressedMatrix<complex<int>,columnMajor>;
14848             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14849 
14850             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14851             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14852             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14853          }
14854          {
14855             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14856             using T2 = CompressedMatrix<int,rowMajor>;
14857             using RT = CompressedMatrix<complex<int>,rowMajor>;
14858             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14859 
14860             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14861             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14862             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14863          }
14864          {
14865             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14866             using T2 = CompressedMatrix<int,columnMajor>;
14867             using RT = CompressedMatrix<complex<int>,columnMajor>;
14868             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14869 
14870             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14871             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14872             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14873          }
14874       }
14875 
14876       // .../IdentityMatrix
14877       {
14878          {
14879             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14880             using T2 = IdentityMatrix<int,rowMajor>;
14881             using RT = HermitianMatrix< CompressedMatrix<complex<int>,rowMajor> >;
14882             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14883 
14884             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14885             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14886             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14887          }
14888          {
14889             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14890             using T2 = IdentityMatrix<int,columnMajor>;
14891             using RT = HermitianMatrix< CompressedMatrix<complex<int>,columnMajor> >;
14892             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14893 
14894             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14895             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14896             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14897          }
14898          {
14899             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14900             using T2 = IdentityMatrix<int,rowMajor>;
14901             using RT = HermitianMatrix< CompressedMatrix<complex<int>,rowMajor> >;
14902             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14903 
14904             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14905             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14906             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14907          }
14908          {
14909             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14910             using T2 = IdentityMatrix<int,columnMajor>;
14911             using RT = HermitianMatrix< CompressedMatrix<complex<int>,columnMajor> >;
14912             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14913 
14914             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14915             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14916             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14917          }
14918       }
14919 
14920       // .../ZeroMatrix
14921       {
14922          {
14923             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14924             using T2 = ZeroMatrix<int,rowMajor>;
14925             using RT = ZeroMatrix<complex<int>,rowMajor>;
14926             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14927 
14928             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14929             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14930             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14931          }
14932          {
14933             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14934             using T2 = ZeroMatrix<int,columnMajor>;
14935             using RT = ZeroMatrix<complex<int>,columnMajor>;
14936             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14937 
14938             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14939             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14940             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14941          }
14942          {
14943             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14944             using T2 = ZeroMatrix<int,rowMajor>;
14945             using RT = ZeroMatrix<complex<int>,rowMajor>;
14946             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14947 
14948             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14949             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14950             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14951          }
14952          {
14953             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14954             using T2 = ZeroMatrix<int,columnMajor>;
14955             using RT = ZeroMatrix<complex<int>,columnMajor>;
14956             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14957 
14958             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14959             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14960             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14961          }
14962       }
14963 
14964       // .../SymmetricMatrix<DynamicMatrix> (real)
14965       {
14966          {
14967             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14968             using T2 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
14969             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14970             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14971 
14972             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14973             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14974             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14975          }
14976          {
14977             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14978             using T2 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
14979             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14980             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14981 
14982             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14983             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14984             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14985          }
14986          {
14987             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14988             using T2 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
14989             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
14990             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
14991 
14992             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
14993             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
14994             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
14995          }
14996          {
14997             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
14998             using T2 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
14999             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15000             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15001 
15002             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15003             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15004             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15005          }
15006       }
15007 
15008       // .../SymmetricMatrix<DynamicMatrix> (complex)
15009       {
15010          {
15011             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15012             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15013             using RT = DynamicMatrix<complex<int>,rowMajor>;
15014             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15015 
15016             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15017             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15018             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15019          }
15020          {
15021             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15022             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15023             using RT = DynamicMatrix<complex<int>,columnMajor>;
15024             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15025 
15026             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15027             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15028             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15029          }
15030          {
15031             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15032             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15033             using RT = DynamicMatrix<complex<int>,rowMajor>;
15034             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15035 
15036             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15037             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15038             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15039          }
15040          {
15041             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15042             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15043             using RT = DynamicMatrix<complex<int>,columnMajor>;
15044             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15045 
15046             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15047             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15048             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15049          }
15050       }
15051 
15052       // .../SymmetricMatrix<UniformMatrix>
15053       {
15054          {
15055             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15056             using T2 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
15057             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15058             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15059 
15060             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15061             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15062             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15063          }
15064          {
15065             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15066             using T2 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
15067             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15068             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15069 
15070             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15071             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15072             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15073          }
15074          {
15075             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15076             using T2 = SymmetricMatrix< UniformMatrix<int,rowMajor> >;
15077             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15078             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15079 
15080             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15081             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15082             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15083          }
15084          {
15085             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15086             using T2 = SymmetricMatrix< UniformMatrix<int,columnMajor> >;
15087             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15088             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15089 
15090             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15091             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15092             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15093          }
15094       }
15095 
15096       // .../SymmetricMatrix<ZeroMatrix>
15097       {
15098          {
15099             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15100             using T2 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
15101             using RT = ZeroMatrix<complex<int>,rowMajor>;
15102             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15103 
15104             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15105             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15106             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15107          }
15108          {
15109             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15110             using T2 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
15111             using RT = ZeroMatrix<complex<int>,columnMajor>;
15112             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15113 
15114             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15115             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15116             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15117          }
15118          {
15119             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15120             using T2 = SymmetricMatrix< ZeroMatrix<int,rowMajor> >;
15121             using RT = ZeroMatrix<complex<int>,rowMajor>;
15122             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15123 
15124             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15125             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15126             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15127          }
15128          {
15129             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15130             using T2 = SymmetricMatrix< ZeroMatrix<int,columnMajor> >;
15131             using RT = ZeroMatrix<complex<int>,columnMajor>;
15132             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15133 
15134             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15135             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15136             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15137          }
15138       }
15139 
15140       // .../HermitianMatrix<DynamicMatrix> (symmetric)
15141       {
15142          {
15143             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15144             using T2 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
15145             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15146             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15147 
15148             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15149             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15150             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15151          }
15152          {
15153             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15154             using T2 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
15155             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15156             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15157 
15158             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15159             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15160             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15161          }
15162          {
15163             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15164             using T2 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
15165             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15166             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15167 
15168             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15169             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15170             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15171          }
15172          {
15173             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15174             using T2 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
15175             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15176             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15177 
15178             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15179             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15180             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15181          }
15182       }
15183 
15184       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
15185       {
15186          {
15187             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15188             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15189             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15190             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15191 
15192             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15193             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15194             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15195          }
15196          {
15197             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15198             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15199             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15200             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15201 
15202             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15203             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15204             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15205          }
15206          {
15207             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15208             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15209             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15210             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15211 
15212             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15213             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15214             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15215          }
15216          {
15217             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15218             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15219             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15220             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15221 
15222             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15223             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15224             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15225          }
15226       }
15227 
15228       // .../LowerMatrix<DynamicMatrix>
15229       {
15230          {
15231             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15232             using T2 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15233             using RT = DynamicMatrix<complex<int>,rowMajor>;
15234             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15235 
15236             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15237             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15238             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15239          }
15240          {
15241             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15242             using T2 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15243             using RT = DynamicMatrix<complex<int>,columnMajor>;
15244             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15245 
15246             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15247             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15248             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15249          }
15250          {
15251             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15252             using T2 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15253             using RT = DynamicMatrix<complex<int>,rowMajor>;
15254             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15255 
15256             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15257             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15258             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15259          }
15260          {
15261             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15262             using T2 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15263             using RT = DynamicMatrix<complex<int>,columnMajor>;
15264             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15265 
15266             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15267             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15268             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15269          }
15270       }
15271 
15272       // .../UniLowerMatrix<DynamicMatrix>
15273       {
15274          {
15275             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15276             using T2 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
15277             using RT = DynamicMatrix<complex<int>,rowMajor>;
15278             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15279 
15280             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15281             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15282             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15283          }
15284          {
15285             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15286             using T2 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
15287             using RT = DynamicMatrix<complex<int>,columnMajor>;
15288             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15289 
15290             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15291             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15292             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15293          }
15294          {
15295             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15296             using T2 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
15297             using RT = DynamicMatrix<complex<int>,rowMajor>;
15298             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15299 
15300             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15301             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15302             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15303          }
15304          {
15305             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15306             using T2 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
15307             using RT = DynamicMatrix<complex<int>,columnMajor>;
15308             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15309 
15310             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15311             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15312             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15313          }
15314       }
15315 
15316       // .../StrictlyLowerMatrix<DynamicMatrix>
15317       {
15318          {
15319             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15320             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
15321             using RT = DynamicMatrix<complex<int>,rowMajor>;
15322             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15323 
15324             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15325             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15326             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15327          }
15328          {
15329             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15330             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
15331             using RT = DynamicMatrix<complex<int>,columnMajor>;
15332             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15333 
15334             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15335             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15336             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15337          }
15338          {
15339             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15340             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
15341             using RT = DynamicMatrix<complex<int>,rowMajor>;
15342             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15343 
15344             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15345             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15346             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15347          }
15348          {
15349             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15350             using T2 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
15351             using RT = DynamicMatrix<complex<int>,columnMajor>;
15352             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15353 
15354             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15355             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15356             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15357          }
15358       }
15359 
15360       // .../UpperMatrix<DynamicMatrix>
15361       {
15362          {
15363             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15364             using T2 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
15365             using RT = DynamicMatrix<complex<int>,rowMajor>;
15366             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15367 
15368             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15369             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15370             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15371          }
15372          {
15373             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15374             using T2 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
15375             using RT = DynamicMatrix<complex<int>,columnMajor>;
15376             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15377 
15378             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15379             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15380             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15381          }
15382          {
15383             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15384             using T2 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
15385             using RT = DynamicMatrix<complex<int>,rowMajor>;
15386             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15387 
15388             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15389             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15390             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15391          }
15392          {
15393             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15394             using T2 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
15395             using RT = DynamicMatrix<complex<int>,columnMajor>;
15396             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15397 
15398             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15399             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15400             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15401          }
15402       }
15403 
15404       // .../UniUpperMatrix<DynamicMatrix>
15405       {
15406          {
15407             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15408             using T2 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
15409             using RT = DynamicMatrix<complex<int>,rowMajor>;
15410             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15411 
15412             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15413             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15414             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15415          }
15416          {
15417             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15418             using T2 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
15419             using RT = DynamicMatrix<complex<int>,columnMajor>;
15420             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15421 
15422             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15423             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15424             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15425          }
15426          {
15427             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15428             using T2 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
15429             using RT = DynamicMatrix<complex<int>,rowMajor>;
15430             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15431 
15432             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15433             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15434             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15435          }
15436          {
15437             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15438             using T2 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
15439             using RT = DynamicMatrix<complex<int>,columnMajor>;
15440             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15441 
15442             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15443             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15444             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15445          }
15446       }
15447 
15448       // .../StrictlyUpperMatrix<DynamicMatrix>
15449       {
15450          {
15451             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15452             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
15453             using RT = DynamicMatrix<complex<int>,rowMajor>;
15454             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15455 
15456             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15457             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15458             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15459          }
15460          {
15461             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15462             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
15463             using RT = DynamicMatrix<complex<int>,columnMajor>;
15464             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15465 
15466             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15467             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15468             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15469          }
15470          {
15471             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15472             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
15473             using RT = DynamicMatrix<complex<int>,rowMajor>;
15474             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15475 
15476             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15477             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15478             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15479          }
15480          {
15481             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15482             using T2 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
15483             using RT = DynamicMatrix<complex<int>,columnMajor>;
15484             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15485 
15486             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15487             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15488             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15489          }
15490       }
15491 
15492       // .../DiagonalMatrix<DynamicMatrix>
15493       {
15494          {
15495             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15496             using T2 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
15497             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15498             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15499 
15500             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15501             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15502             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15503          }
15504          {
15505             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15506             using T2 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
15507             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15508             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15509 
15510             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15511             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15512             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15513          }
15514          {
15515             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15516             using T2 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
15517             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15518             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15519 
15520             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15521             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15522             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15523          }
15524          {
15525             using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15526             using T2 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
15527             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15528             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15529 
15530             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15531             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15532             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15533          }
15534       }
15535    }
15536 
15537    // LowerMatrix<DynamicMatrix>/...
15538    {
15539       // .../StaticMatrix
15540       {
15541          {
15542             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15543             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
15544             using RT = DynamicMatrix<double,rowMajor>;
15545             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15546 
15547             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15548             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15549             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15550          }
15551          {
15552             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15553             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
15554             using RT = DynamicMatrix<double,columnMajor>;
15555             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15556 
15557             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15558             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15559             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15560          }
15561          {
15562             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15563             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
15564             using RT = DynamicMatrix<double,rowMajor>;
15565             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15566 
15567             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15568             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15569             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15570          }
15571          {
15572             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15573             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
15574             using RT = DynamicMatrix<double,columnMajor>;
15575             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15576 
15577             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15578             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15579             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15580          }
15581       }
15582 
15583       // .../HybridMatrix
15584       {
15585          {
15586             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15587             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
15588             using RT = DynamicMatrix<double,rowMajor>;
15589             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15590 
15591             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15592             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15593             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15594          }
15595          {
15596             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15597             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
15598             using RT = DynamicMatrix<double,columnMajor>;
15599             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15600 
15601             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15602             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15603             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15604          }
15605          {
15606             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15607             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
15608             using RT = DynamicMatrix<double,rowMajor>;
15609             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15610 
15611             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15612             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15613             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15614          }
15615          {
15616             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15617             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
15618             using RT = DynamicMatrix<double,columnMajor>;
15619             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15620 
15621             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15622             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15623             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15624          }
15625       }
15626 
15627       // .../DynamicMatrix
15628       {
15629          {
15630             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15631             using T2 = DynamicMatrix<double,rowMajor>;
15632             using RT = DynamicMatrix<double,rowMajor>;
15633             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15634 
15635             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15636             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15637             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15638          }
15639          {
15640             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15641             using T2 = DynamicMatrix<double,columnMajor>;
15642             using RT = DynamicMatrix<double,columnMajor>;
15643             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15644 
15645             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15646             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15647             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15648          }
15649          {
15650             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15651             using T2 = DynamicMatrix<double,rowMajor>;
15652             using RT = DynamicMatrix<double,rowMajor>;
15653             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15654 
15655             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15656             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15657             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15658          }
15659          {
15660             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15661             using T2 = DynamicMatrix<double,columnMajor>;
15662             using RT = DynamicMatrix<double,columnMajor>;
15663             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15664 
15665             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15666             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15667             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15668          }
15669       }
15670 
15671       // .../CustomMatrix
15672       {
15673          {
15674             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15675             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
15676             using RT = DynamicMatrix<double,rowMajor>;
15677             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15678 
15679             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15680             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15681             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15682          }
15683          {
15684             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15685             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
15686             using RT = DynamicMatrix<double,columnMajor>;
15687             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15688 
15689             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15690             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15691             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15692          }
15693          {
15694             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15695             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
15696             using RT = DynamicMatrix<double,rowMajor>;
15697             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15698 
15699             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15700             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15701             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15702          }
15703          {
15704             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15705             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
15706             using RT = DynamicMatrix<double,columnMajor>;
15707             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15708 
15709             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15710             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15711             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15712          }
15713       }
15714 
15715       // .../UniformMatrix
15716       {
15717          {
15718             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15719             using T2 = UniformMatrix<double,rowMajor>;
15720             using RT = DynamicMatrix<double,rowMajor>;
15721             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15722 
15723             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15724             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15725             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15726          }
15727          {
15728             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15729             using T2 = UniformMatrix<double,columnMajor>;
15730             using RT = DynamicMatrix<double,columnMajor>;
15731             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15732 
15733             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15734             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15735             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15736          }
15737          {
15738             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15739             using T2 = UniformMatrix<double,rowMajor>;
15740             using RT = DynamicMatrix<double,rowMajor>;
15741             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15742 
15743             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15744             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15745             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15746          }
15747          {
15748             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15749             using T2 = UniformMatrix<double,columnMajor>;
15750             using RT = DynamicMatrix<double,columnMajor>;
15751             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15752 
15753             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15754             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15755             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15756          }
15757       }
15758 
15759       // .../InitializerMatrix
15760       {
15761          {
15762             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15763             using T2 = InitializerMatrix<double>;
15764             using RT = DynamicMatrix<double,rowMajor>;
15765             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15766 
15767             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15768             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15769             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15770          }
15771          {
15772             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15773             using T2 = InitializerMatrix<double>;
15774             using RT = DynamicMatrix<double,rowMajor>;
15775             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15776 
15777             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15778             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15779             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15780          }
15781       }
15782 
15783       // .../CompressedMatrix
15784       {
15785          {
15786             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15787             using T2 = CompressedMatrix<double,rowMajor>;
15788             using RT = CompressedMatrix<double,rowMajor>;
15789             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15790 
15791             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15792             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15793             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15794          }
15795          {
15796             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15797             using T2 = CompressedMatrix<double,columnMajor>;
15798             using RT = CompressedMatrix<double,columnMajor>;
15799             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15800 
15801             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15802             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15803             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15804          }
15805          {
15806             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15807             using T2 = CompressedMatrix<double,rowMajor>;
15808             using RT = CompressedMatrix<double,rowMajor>;
15809             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15810 
15811             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15812             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15813             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15814          }
15815          {
15816             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15817             using T2 = CompressedMatrix<double,columnMajor>;
15818             using RT = CompressedMatrix<double,columnMajor>;
15819             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15820 
15821             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15822             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15823             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15824          }
15825       }
15826 
15827       // .../IdentityMatrix
15828       {
15829          {
15830             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15831             using T2 = IdentityMatrix<double,rowMajor>;
15832             using RT = LowerMatrix< CompressedMatrix<double,rowMajor> >;
15833             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15834 
15835             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15836             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15837             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15838          }
15839          {
15840             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15841             using T2 = IdentityMatrix<double,columnMajor>;
15842             using RT = LowerMatrix< CompressedMatrix<double,columnMajor> >;
15843             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15844 
15845             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15846             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15847             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15848          }
15849          {
15850             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15851             using T2 = IdentityMatrix<double,rowMajor>;
15852             using RT = LowerMatrix< CompressedMatrix<double,rowMajor> >;
15853             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15854 
15855             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15856             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15857             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15858          }
15859          {
15860             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15861             using T2 = IdentityMatrix<double,columnMajor>;
15862             using RT = LowerMatrix< CompressedMatrix<double,columnMajor> >;
15863             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15864 
15865             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15866             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15867             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15868          }
15869       }
15870 
15871       // .../ZeroMatrix
15872       {
15873          {
15874             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15875             using T2 = ZeroMatrix<double,rowMajor>;
15876             using RT = ZeroMatrix<double,rowMajor>;
15877             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15878 
15879             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15880             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15881             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15882          }
15883          {
15884             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15885             using T2 = ZeroMatrix<double,columnMajor>;
15886             using RT = ZeroMatrix<double,columnMajor>;
15887             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15888 
15889             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15890             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15891             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15892          }
15893          {
15894             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15895             using T2 = ZeroMatrix<double,rowMajor>;
15896             using RT = ZeroMatrix<double,rowMajor>;
15897             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15898 
15899             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15900             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15901             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15902          }
15903          {
15904             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15905             using T2 = ZeroMatrix<double,columnMajor>;
15906             using RT = ZeroMatrix<double,columnMajor>;
15907             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15908 
15909             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15910             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15911             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15912          }
15913       }
15914 
15915       // .../SymmetricMatrix<DynamicMatrix> (real)
15916       {
15917          {
15918             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15919             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
15920             using RT = DynamicMatrix<double,rowMajor>;
15921             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15922 
15923             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15924             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15925             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15926          }
15927          {
15928             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15929             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
15930             using RT = DynamicMatrix<double,columnMajor>;
15931             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15932 
15933             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15934             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15935             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15936          }
15937          {
15938             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15939             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
15940             using RT = DynamicMatrix<double,rowMajor>;
15941             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15942 
15943             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15944             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15945             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15946          }
15947          {
15948             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15949             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
15950             using RT = DynamicMatrix<double,columnMajor>;
15951             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15952 
15953             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15954             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15955             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15956          }
15957       }
15958 
15959       // .../SymmetricMatrix<DynamicMatrix> (complex)
15960       {
15961          {
15962             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15963             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15964             using RT = DynamicMatrix<complex<int>,rowMajor>;
15965             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15966 
15967             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15968             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15969             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15970          }
15971          {
15972             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
15973             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15974             using RT = DynamicMatrix<complex<int>,columnMajor>;
15975             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15976 
15977             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15978             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15979             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15980          }
15981          {
15982             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15983             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
15984             using RT = DynamicMatrix<complex<int>,rowMajor>;
15985             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15986 
15987             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15988             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15989             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
15990          }
15991          {
15992             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
15993             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
15994             using RT = DynamicMatrix<complex<int>,columnMajor>;
15995             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
15996 
15997             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
15998             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
15999             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16000          }
16001       }
16002 
16003       // .../SymmetricMatrix<UniformMatrix>
16004       {
16005          {
16006             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16007             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
16008             using RT = DynamicMatrix<double,rowMajor>;
16009             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16010 
16011             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16012             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16013             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16014          }
16015          {
16016             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16017             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
16018             using RT = DynamicMatrix<double,columnMajor>;
16019             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16020 
16021             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16022             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16023             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16024          }
16025          {
16026             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16027             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
16028             using RT = DynamicMatrix<double,rowMajor>;
16029             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16030 
16031             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16032             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16033             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16034          }
16035          {
16036             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16037             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
16038             using RT = DynamicMatrix<double,columnMajor>;
16039             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16040 
16041             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16042             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16043             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16044          }
16045       }
16046 
16047       // .../SymmetricMatrix<ZeroMatrix>
16048       {
16049          {
16050             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16051             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
16052             using RT = ZeroMatrix<double,rowMajor>;
16053             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16054 
16055             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16056             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16057             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16058          }
16059          {
16060             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16061             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
16062             using RT = ZeroMatrix<double,columnMajor>;
16063             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16064 
16065             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16066             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16067             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16068          }
16069          {
16070             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16071             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
16072             using RT = ZeroMatrix<double,rowMajor>;
16073             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16074 
16075             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16076             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16077             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16078          }
16079          {
16080             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16081             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
16082             using RT = ZeroMatrix<double,columnMajor>;
16083             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16084 
16085             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16086             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16087             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16088          }
16089       }
16090 
16091       // .../HermitianMatrix<DynamicMatrix> (symmetric)
16092       {
16093          {
16094             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16095             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
16096             using RT = DynamicMatrix<double,rowMajor>;
16097             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16098 
16099             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16100             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16101             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16102          }
16103          {
16104             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16105             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
16106             using RT = DynamicMatrix<double,columnMajor>;
16107             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16108 
16109             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16110             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16111             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16112          }
16113          {
16114             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16115             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
16116             using RT = DynamicMatrix<double,rowMajor>;
16117             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16118 
16119             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16120             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16121             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16122          }
16123          {
16124             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16125             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
16126             using RT = DynamicMatrix<double,columnMajor>;
16127             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16128 
16129             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16130             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16131             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16132          }
16133       }
16134 
16135       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
16136       {
16137          {
16138             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16139             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
16140             using RT = DynamicMatrix<complex<int>,rowMajor>;
16141             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16142 
16143             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16144             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16145             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16146          }
16147          {
16148             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16149             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
16150             using RT = DynamicMatrix<complex<int>,columnMajor>;
16151             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16152 
16153             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16154             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16155             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16156          }
16157          {
16158             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16159             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
16160             using RT = DynamicMatrix<complex<int>,rowMajor>;
16161             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16162 
16163             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16164             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16165             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16166          }
16167          {
16168             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16169             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
16170             using RT = DynamicMatrix<complex<int>,columnMajor>;
16171             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16172 
16173             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16174             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16175             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16176          }
16177       }
16178 
16179       // .../LowerMatrix<DynamicMatrix>
16180       {
16181          {
16182             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16183             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16184             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16185             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16186 
16187             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16188             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16189             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16190          }
16191          {
16192             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16193             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16194             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16195             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16196 
16197             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16198             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16199             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16200          }
16201          {
16202             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16203             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16204             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16205             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16206 
16207             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16208             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16209             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16210          }
16211          {
16212             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16213             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16214             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16215             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16216 
16217             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16218             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16219             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16220          }
16221       }
16222 
16223       // .../UniLowerMatrix<DynamicMatrix>
16224       {
16225          {
16226             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16227             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
16228             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16229             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16230 
16231             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16232             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16233             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16234          }
16235          {
16236             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16237             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
16238             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16239             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16240 
16241             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16242             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16243             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16244          }
16245          {
16246             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16247             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
16248             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16249             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16250 
16251             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16252             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16253             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16254          }
16255          {
16256             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16257             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
16258             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16259             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16260 
16261             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16262             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16263             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16264          }
16265       }
16266 
16267       // .../StrictlyLowerMatrix<DynamicMatrix>
16268       {
16269          {
16270             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16271             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
16272             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
16273             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16274 
16275             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16276             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16277             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16278          }
16279          {
16280             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16281             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
16282             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
16283             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16284 
16285             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16286             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16287             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16288          }
16289          {
16290             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16291             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
16292             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
16293             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16294 
16295             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16296             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16297             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16298          }
16299          {
16300             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16301             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
16302             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
16303             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16304 
16305             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16306             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16307             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16308          }
16309       }
16310 
16311       // .../UpperMatrix<DynamicMatrix>
16312       {
16313          {
16314             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16315             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
16316             using RT = DynamicMatrix<double,rowMajor>;
16317             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16318 
16319             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16320             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16321             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16322          }
16323          {
16324             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16325             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
16326             using RT = DynamicMatrix<double,columnMajor>;
16327             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16328 
16329             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16330             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16331             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16332          }
16333          {
16334             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16335             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
16336             using RT = DynamicMatrix<double,rowMajor>;
16337             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16338 
16339             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16340             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16341             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16342          }
16343          {
16344             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16345             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
16346             using RT = DynamicMatrix<double,columnMajor>;
16347             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16348 
16349             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16350             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16351             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16352          }
16353       }
16354 
16355       // .../UniUpperMatrix<DynamicMatrix>
16356       {
16357          {
16358             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16359             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
16360             using RT = DynamicMatrix<double,rowMajor>;
16361             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16362 
16363             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16364             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16365             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16366          }
16367          {
16368             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16369             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
16370             using RT = DynamicMatrix<double,columnMajor>;
16371             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16372 
16373             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16374             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16375             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16376          }
16377          {
16378             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16379             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
16380             using RT = DynamicMatrix<double,rowMajor>;
16381             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16382 
16383             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16384             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16385             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16386          }
16387          {
16388             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16389             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
16390             using RT = DynamicMatrix<double,columnMajor>;
16391             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16392 
16393             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16394             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16395             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16396          }
16397       }
16398 
16399       // .../StrictlyUpperMatrix<DynamicMatrix>
16400       {
16401          {
16402             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16403             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
16404             using RT = DynamicMatrix<double,rowMajor>;
16405             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16406 
16407             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16408             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16409             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16410          }
16411          {
16412             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16413             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
16414             using RT = DynamicMatrix<double,columnMajor>;
16415             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16416 
16417             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16418             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16419             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16420          }
16421          {
16422             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16423             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
16424             using RT = DynamicMatrix<double,rowMajor>;
16425             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16426 
16427             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16428             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16429             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16430          }
16431          {
16432             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16433             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
16434             using RT = DynamicMatrix<double,columnMajor>;
16435             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16436 
16437             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16438             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16439             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16440          }
16441       }
16442 
16443       // .../DiagonalMatrix<DynamicMatrix>
16444       {
16445          {
16446             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16447             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
16448             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16449             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16450 
16451             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16452             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16453             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16454          }
16455          {
16456             using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
16457             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
16458             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16459             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16460 
16461             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16462             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16463             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16464          }
16465          {
16466             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16467             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
16468             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
16469             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16470 
16471             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16472             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16473             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16474          }
16475          {
16476             using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
16477             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
16478             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
16479             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16480 
16481             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16482             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16483             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16484          }
16485       }
16486    }
16487 
16488    // UniLowerMatrix<DynamicMatrix>/...
16489    {
16490       // .../StaticMatrix
16491       {
16492          {
16493             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16494             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
16495             using RT = DynamicMatrix<double,rowMajor>;
16496             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16497 
16498             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16499             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16500             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16501          }
16502          {
16503             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16504             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
16505             using RT = DynamicMatrix<double,columnMajor>;
16506             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16507 
16508             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16509             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16510             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16511          }
16512          {
16513             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16514             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
16515             using RT = DynamicMatrix<double,rowMajor>;
16516             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16517 
16518             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16519             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16520             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16521          }
16522          {
16523             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16524             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
16525             using RT = DynamicMatrix<double,columnMajor>;
16526             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16527 
16528             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16529             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16530             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16531          }
16532       }
16533 
16534       // .../HybridMatrix
16535       {
16536          {
16537             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16538             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
16539             using RT = DynamicMatrix<double,rowMajor>;
16540             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16541 
16542             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16543             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16544             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16545          }
16546          {
16547             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16548             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
16549             using RT = DynamicMatrix<double,columnMajor>;
16550             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16551 
16552             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16553             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16554             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16555          }
16556          {
16557             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16558             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
16559             using RT = DynamicMatrix<double,rowMajor>;
16560             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16561 
16562             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16563             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16564             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16565          }
16566          {
16567             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16568             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
16569             using RT = DynamicMatrix<double,columnMajor>;
16570             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16571 
16572             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16573             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16574             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16575          }
16576       }
16577 
16578       // .../DynamicMatrix
16579       {
16580          {
16581             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16582             using T2 = DynamicMatrix<double,rowMajor>;
16583             using RT = DynamicMatrix<double,rowMajor>;
16584             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16585 
16586             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16587             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16588             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16589          }
16590          {
16591             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16592             using T2 = DynamicMatrix<double,columnMajor>;
16593             using RT = DynamicMatrix<double,columnMajor>;
16594             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16595 
16596             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16597             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16598             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16599          }
16600          {
16601             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16602             using T2 = DynamicMatrix<double,rowMajor>;
16603             using RT = DynamicMatrix<double,rowMajor>;
16604             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16605 
16606             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16607             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16608             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16609          }
16610          {
16611             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16612             using T2 = DynamicMatrix<double,columnMajor>;
16613             using RT = DynamicMatrix<double,columnMajor>;
16614             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16615 
16616             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16617             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16618             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16619          }
16620       }
16621 
16622       // .../CustomMatrix
16623       {
16624          {
16625             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16626             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
16627             using RT = DynamicMatrix<double,rowMajor>;
16628             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16629 
16630             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16631             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16632             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16633          }
16634          {
16635             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16636             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
16637             using RT = DynamicMatrix<double,columnMajor>;
16638             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16639 
16640             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16641             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16642             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16643          }
16644          {
16645             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16646             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
16647             using RT = DynamicMatrix<double,rowMajor>;
16648             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16649 
16650             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16651             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16652             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16653          }
16654          {
16655             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16656             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
16657             using RT = DynamicMatrix<double,columnMajor>;
16658             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16659 
16660             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16661             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16662             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16663          }
16664       }
16665 
16666       // .../UniformMatrix
16667       {
16668          {
16669             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16670             using T2 = UniformMatrix<double,rowMajor>;
16671             using RT = DynamicMatrix<double,rowMajor>;
16672             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16673 
16674             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16675             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16676             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16677          }
16678          {
16679             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16680             using T2 = UniformMatrix<double,columnMajor>;
16681             using RT = DynamicMatrix<double,columnMajor>;
16682             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16683 
16684             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16685             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16686             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16687          }
16688          {
16689             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16690             using T2 = UniformMatrix<double,rowMajor>;
16691             using RT = DynamicMatrix<double,rowMajor>;
16692             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16693 
16694             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16695             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16696             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16697          }
16698          {
16699             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16700             using T2 = UniformMatrix<double,columnMajor>;
16701             using RT = DynamicMatrix<double,columnMajor>;
16702             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16703 
16704             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16705             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16706             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16707          }
16708       }
16709 
16710       // .../InitializerMatrix
16711       {
16712          {
16713             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16714             using T2 = InitializerMatrix<double>;
16715             using RT = DynamicMatrix<double,rowMajor>;
16716             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16717 
16718             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16719             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16720             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16721          }
16722          {
16723             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16724             using T2 = InitializerMatrix<double>;
16725             using RT = DynamicMatrix<double,rowMajor>;
16726             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16727 
16728             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16729             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16730             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16731          }
16732       }
16733 
16734       // .../CompressedMatrix
16735       {
16736          {
16737             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16738             using T2 = CompressedMatrix<double,rowMajor>;
16739             using RT = CompressedMatrix<double,rowMajor>;
16740             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16741 
16742             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16743             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16744             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16745          }
16746          {
16747             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16748             using T2 = CompressedMatrix<double,columnMajor>;
16749             using RT = CompressedMatrix<double,columnMajor>;
16750             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16751 
16752             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16753             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16754             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16755          }
16756          {
16757             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16758             using T2 = CompressedMatrix<double,rowMajor>;
16759             using RT = CompressedMatrix<double,rowMajor>;
16760             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16761 
16762             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16763             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16764             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16765          }
16766          {
16767             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16768             using T2 = CompressedMatrix<double,columnMajor>;
16769             using RT = CompressedMatrix<double,columnMajor>;
16770             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16771 
16772             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16773             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16774             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16775          }
16776       }
16777 
16778       // .../IdentityMatrix
16779       {
16780          {
16781             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16782             using T2 = IdentityMatrix<double,rowMajor>;
16783             using RT = UniLowerMatrix< CompressedMatrix<double,rowMajor> >;
16784             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16785 
16786             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16787             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16788             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16789          }
16790          {
16791             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16792             using T2 = IdentityMatrix<double,columnMajor>;
16793             using RT = UniLowerMatrix< CompressedMatrix<double,columnMajor> >;
16794             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16795 
16796             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16797             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16798             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16799          }
16800          {
16801             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16802             using T2 = IdentityMatrix<double,rowMajor>;
16803             using RT = UniLowerMatrix< CompressedMatrix<double,rowMajor> >;
16804             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16805 
16806             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16807             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16808             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16809          }
16810          {
16811             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16812             using T2 = IdentityMatrix<double,columnMajor>;
16813             using RT = UniLowerMatrix< CompressedMatrix<double,columnMajor> >;
16814             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16815 
16816             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16817             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16818             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16819          }
16820       }
16821 
16822       // .../ZeroMatrix
16823       {
16824          {
16825             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16826             using T2 = ZeroMatrix<double,rowMajor>;
16827             using RT = ZeroMatrix<double,rowMajor>;
16828             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16829 
16830             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16831             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16832             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16833          }
16834          {
16835             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16836             using T2 = ZeroMatrix<double,columnMajor>;
16837             using RT = ZeroMatrix<double,columnMajor>;
16838             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16839 
16840             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16841             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16842             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16843          }
16844          {
16845             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16846             using T2 = ZeroMatrix<double,rowMajor>;
16847             using RT = ZeroMatrix<double,rowMajor>;
16848             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16849 
16850             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16851             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16852             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16853          }
16854          {
16855             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16856             using T2 = ZeroMatrix<double,columnMajor>;
16857             using RT = ZeroMatrix<double,columnMajor>;
16858             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16859 
16860             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16861             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16862             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16863          }
16864       }
16865 
16866       // .../SymmetricMatrix<DynamicMatrix> (real)
16867       {
16868          {
16869             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16870             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
16871             using RT = DynamicMatrix<double,rowMajor>;
16872             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16873 
16874             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16875             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16876             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16877          }
16878          {
16879             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16880             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
16881             using RT = DynamicMatrix<double,columnMajor>;
16882             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16883 
16884             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16885             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16886             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16887          }
16888          {
16889             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16890             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
16891             using RT = DynamicMatrix<double,rowMajor>;
16892             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16893 
16894             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16895             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16896             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16897          }
16898          {
16899             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16900             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
16901             using RT = DynamicMatrix<double,columnMajor>;
16902             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16903 
16904             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16905             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16906             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16907          }
16908       }
16909 
16910       // .../SymmetricMatrix<DynamicMatrix> (complex)
16911       {
16912          {
16913             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16914             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
16915             using RT = DynamicMatrix<complex<int>,rowMajor>;
16916             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16917 
16918             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16919             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16920             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16921          }
16922          {
16923             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16924             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
16925             using RT = DynamicMatrix<complex<int>,columnMajor>;
16926             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16927 
16928             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16929             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16930             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16931          }
16932          {
16933             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16934             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
16935             using RT = DynamicMatrix<complex<int>,rowMajor>;
16936             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16937 
16938             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16939             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16940             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16941          }
16942          {
16943             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16944             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
16945             using RT = DynamicMatrix<complex<int>,columnMajor>;
16946             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16947 
16948             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16949             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16950             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16951          }
16952       }
16953 
16954       // .../SymmetricMatrix<UniformMatrix>
16955       {
16956          {
16957             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16958             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
16959             using RT = DynamicMatrix<double,rowMajor>;
16960             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16961 
16962             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16963             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16964             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16965          }
16966          {
16967             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
16968             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
16969             using RT = DynamicMatrix<double,columnMajor>;
16970             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16971 
16972             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16973             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16974             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16975          }
16976          {
16977             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16978             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
16979             using RT = DynamicMatrix<double,rowMajor>;
16980             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16981 
16982             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16983             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16984             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16985          }
16986          {
16987             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
16988             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
16989             using RT = DynamicMatrix<double,columnMajor>;
16990             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
16991 
16992             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
16993             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
16994             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
16995          }
16996       }
16997 
16998       // .../SymmetricMatrix<ZeroMatrix>
16999       {
17000          {
17001             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17002             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
17003             using RT = ZeroMatrix<double,rowMajor>;
17004             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17005 
17006             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17007             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17008             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17009          }
17010          {
17011             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17012             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
17013             using RT = ZeroMatrix<double,columnMajor>;
17014             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17015 
17016             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17017             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17018             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17019          }
17020          {
17021             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17022             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
17023             using RT = ZeroMatrix<double,rowMajor>;
17024             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17025 
17026             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17027             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17028             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17029          }
17030          {
17031             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17032             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
17033             using RT = ZeroMatrix<double,columnMajor>;
17034             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17035 
17036             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17037             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17038             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17039          }
17040       }
17041 
17042       // .../HermitianMatrix<DynamicMatrix> (symmetric)
17043       {
17044          {
17045             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17046             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
17047             using RT = DynamicMatrix<double,rowMajor>;
17048             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17049 
17050             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17051             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17052             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17053          }
17054          {
17055             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17056             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
17057             using RT = DynamicMatrix<double,columnMajor>;
17058             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17059 
17060             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17061             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17062             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17063          }
17064          {
17065             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17066             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
17067             using RT = DynamicMatrix<double,rowMajor>;
17068             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17069 
17070             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17071             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17072             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17073          }
17074          {
17075             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17076             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
17077             using RT = DynamicMatrix<double,columnMajor>;
17078             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17079 
17080             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17081             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17082             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17083          }
17084       }
17085 
17086       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
17087       {
17088          {
17089             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17090             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
17091             using RT = DynamicMatrix<complex<int>,rowMajor>;
17092             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17093 
17094             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17095             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17096             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17097          }
17098          {
17099             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17100             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
17101             using RT = DynamicMatrix<complex<int>,columnMajor>;
17102             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17103 
17104             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17105             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17106             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17107          }
17108          {
17109             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17110             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
17111             using RT = DynamicMatrix<complex<int>,rowMajor>;
17112             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17113 
17114             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17115             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17116             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17117          }
17118          {
17119             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17120             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
17121             using RT = DynamicMatrix<complex<int>,columnMajor>;
17122             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17123 
17124             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17125             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17126             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17127          }
17128       }
17129 
17130       // .../LowerMatrix<DynamicMatrix>
17131       {
17132          {
17133             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17134             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
17135             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
17136             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17137 
17138             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17139             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17140             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17141          }
17142          {
17143             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17144             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
17145             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
17146             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17147 
17148             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17149             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17150             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17151          }
17152          {
17153             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17154             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
17155             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
17156             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17157 
17158             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17159             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17160             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17161          }
17162          {
17163             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17164             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
17165             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
17166             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17167 
17168             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17169             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17170             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17171          }
17172       }
17173 
17174       // .../UniLowerMatrix<DynamicMatrix>
17175       {
17176          {
17177             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17178             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
17179             using RT = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
17180             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17181 
17182             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17183             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17184             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17185          }
17186          {
17187             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17188             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
17189             using RT = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
17190             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17191 
17192             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17193             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17194             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17195          }
17196          {
17197             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17198             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
17199             using RT = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
17200             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17201 
17202             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17203             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17204             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17205          }
17206          {
17207             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17208             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
17209             using RT = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
17210             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17211 
17212             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17213             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17214             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17215          }
17216       }
17217 
17218       // .../StrictlyLowerMatrix<DynamicMatrix>
17219       {
17220          {
17221             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17222             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17223             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17224             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17225 
17226             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17227             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17228             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17229          }
17230          {
17231             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17232             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17233             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17234             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17235 
17236             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17237             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17238             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17239          }
17240          {
17241             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17242             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17243             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17244             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17245 
17246             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17247             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17248             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17249          }
17250          {
17251             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17252             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17253             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17254             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17255 
17256             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17257             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17258             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17259          }
17260       }
17261 
17262       // .../UpperMatrix<DynamicMatrix>
17263       {
17264          {
17265             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17266             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
17267             using RT = DynamicMatrix<double,rowMajor>;
17268             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17269 
17270             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17271             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17272             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17273          }
17274          {
17275             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17276             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
17277             using RT = DynamicMatrix<double,columnMajor>;
17278             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17279 
17280             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17281             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17282             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17283          }
17284          {
17285             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17286             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
17287             using RT = DynamicMatrix<double,rowMajor>;
17288             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17289 
17290             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17291             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17292             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17293          }
17294          {
17295             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17296             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
17297             using RT = DynamicMatrix<double,columnMajor>;
17298             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17299 
17300             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17301             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17302             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17303          }
17304       }
17305 
17306       // .../UniUpperMatrix<DynamicMatrix>
17307       {
17308          {
17309             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17310             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
17311             using RT = DynamicMatrix<double,rowMajor>;
17312             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17313 
17314             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17315             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17316             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17317          }
17318          {
17319             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17320             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
17321             using RT = DynamicMatrix<double,columnMajor>;
17322             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17323 
17324             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17325             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17326             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17327          }
17328          {
17329             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17330             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
17331             using RT = DynamicMatrix<double,rowMajor>;
17332             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17333 
17334             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17335             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17336             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17337          }
17338          {
17339             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17340             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
17341             using RT = DynamicMatrix<double,columnMajor>;
17342             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17343 
17344             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17345             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17346             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17347          }
17348       }
17349 
17350       // .../StrictlyUpperMatrix<DynamicMatrix>
17351       {
17352          {
17353             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17354             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
17355             using RT = DynamicMatrix<double,rowMajor>;
17356             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17357 
17358             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17359             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17360             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17361          }
17362          {
17363             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17364             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
17365             using RT = DynamicMatrix<double,columnMajor>;
17366             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17367 
17368             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17369             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17370             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17371          }
17372          {
17373             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17374             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
17375             using RT = DynamicMatrix<double,rowMajor>;
17376             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17377 
17378             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17379             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17380             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17381          }
17382          {
17383             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17384             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
17385             using RT = DynamicMatrix<double,columnMajor>;
17386             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17387 
17388             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17389             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17390             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17391          }
17392       }
17393 
17394       // .../DiagonalMatrix<DynamicMatrix>
17395       {
17396          {
17397             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17398             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
17399             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
17400             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17401 
17402             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17403             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17404             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17405          }
17406          {
17407             using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
17408             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
17409             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
17410             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17411 
17412             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17413             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17414             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17415          }
17416          {
17417             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17418             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
17419             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
17420             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17421 
17422             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17423             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17424             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17425          }
17426          {
17427             using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
17428             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
17429             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
17430             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17431 
17432             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17433             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17434             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17435          }
17436       }
17437    }
17438 
17439    // StrictlyLowerMatrix<DynamicMatrix>/...
17440    {
17441       // .../StaticMatrix
17442       {
17443          {
17444             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17445             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
17446             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17447             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17448 
17449             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17450             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17451             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17452          }
17453          {
17454             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17455             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
17456             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17457             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17458 
17459             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17460             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17461             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17462          }
17463          {
17464             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17465             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
17466             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17467             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17468 
17469             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17470             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17471             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17472          }
17473          {
17474             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17475             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
17476             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17477             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17478 
17479             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17480             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17481             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17482          }
17483       }
17484 
17485       // .../HybridMatrix
17486       {
17487          {
17488             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17489             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
17490             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17491             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17492 
17493             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17494             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17495             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17496          }
17497          {
17498             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17499             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
17500             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17501             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17502 
17503             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17504             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17505             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17506          }
17507          {
17508             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17509             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
17510             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17511             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17512 
17513             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17514             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17515             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17516          }
17517          {
17518             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17519             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
17520             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17521             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17522 
17523             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17524             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17525             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17526          }
17527       }
17528 
17529       // .../DynamicMatrix
17530       {
17531          {
17532             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17533             using T2 = DynamicMatrix<double,rowMajor>;
17534             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17535             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17536 
17537             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17538             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17539             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17540          }
17541          {
17542             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17543             using T2 = DynamicMatrix<double,columnMajor>;
17544             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17545             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17546 
17547             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17548             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17549             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17550          }
17551          {
17552             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17553             using T2 = DynamicMatrix<double,rowMajor>;
17554             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17555             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17556 
17557             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17558             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17559             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17560          }
17561          {
17562             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17563             using T2 = DynamicMatrix<double,columnMajor>;
17564             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17565             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17566 
17567             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17568             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17569             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17570          }
17571       }
17572 
17573       // .../CustomMatrix
17574       {
17575          {
17576             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17577             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
17578             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17579             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17580 
17581             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17582             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17583             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17584          }
17585          {
17586             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17587             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
17588             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17589             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17590 
17591             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17592             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17593             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17594          }
17595          {
17596             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17597             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
17598             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17599             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17600 
17601             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17602             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17603             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17604          }
17605          {
17606             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17607             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
17608             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17609             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17610 
17611             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17612             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17613             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17614          }
17615       }
17616 
17617       // .../UniformMatrix
17618       {
17619          {
17620             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17621             using T2 = UniformMatrix<double,rowMajor>;
17622             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17623             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17624 
17625             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17626             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17627             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17628          }
17629          {
17630             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17631             using T2 = UniformMatrix<double,columnMajor>;
17632             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17633             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17634 
17635             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17636             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17637             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17638          }
17639          {
17640             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17641             using T2 = UniformMatrix<double,rowMajor>;
17642             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17643             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17644 
17645             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17646             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17647             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17648          }
17649          {
17650             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17651             using T2 = UniformMatrix<double,columnMajor>;
17652             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17653             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17654 
17655             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17656             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17657             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17658          }
17659       }
17660 
17661       // .../InitializerMatrix
17662       {
17663          {
17664             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17665             using T2 = InitializerMatrix<double>;
17666             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17667             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17668 
17669             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17670             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17671             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17672          }
17673          {
17674             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17675             using T2 = InitializerMatrix<double>;
17676             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17677             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17678 
17679             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17680             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17681             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17682          }
17683       }
17684 
17685       // .../CompressedMatrix
17686       {
17687          {
17688             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17689             using T2 = CompressedMatrix<double,rowMajor>;
17690             using RT = StrictlyLowerMatrix< CompressedMatrix<double,rowMajor> >;
17691             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17692 
17693             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17694             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17695             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17696          }
17697          {
17698             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17699             using T2 = CompressedMatrix<double,columnMajor>;
17700             using RT = StrictlyLowerMatrix< CompressedMatrix<double,columnMajor> >;
17701             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17702 
17703             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17704             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17705             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17706          }
17707          {
17708             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17709             using T2 = CompressedMatrix<double,rowMajor>;
17710             using RT = StrictlyLowerMatrix< CompressedMatrix<double,rowMajor> >;
17711             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17712 
17713             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17714             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17715             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17716          }
17717          {
17718             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17719             using T2 = CompressedMatrix<double,columnMajor>;
17720             using RT = StrictlyLowerMatrix< CompressedMatrix<double,columnMajor> >;
17721             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17722 
17723             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17724             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17725             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17726          }
17727       }
17728 
17729       // .../IdentityMatrix
17730       {
17731          {
17732             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17733             using T2 = IdentityMatrix<double,rowMajor>;
17734             using RT = StrictlyLowerMatrix< CompressedMatrix<double,rowMajor> >;
17735             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17736 
17737             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17738             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17739             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17740          }
17741          {
17742             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17743             using T2 = IdentityMatrix<double,columnMajor>;
17744             using RT = StrictlyLowerMatrix< CompressedMatrix<double,columnMajor> >;
17745             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17746 
17747             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17748             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17749             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17750          }
17751          {
17752             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17753             using T2 = IdentityMatrix<double,rowMajor>;
17754             using RT = StrictlyLowerMatrix< CompressedMatrix<double,rowMajor> >;
17755             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17756 
17757             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17758             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17759             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17760          }
17761          {
17762             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17763             using T2 = IdentityMatrix<double,columnMajor>;
17764             using RT = StrictlyLowerMatrix< CompressedMatrix<double,columnMajor> >;
17765             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17766 
17767             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17768             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17769             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17770          }
17771       }
17772 
17773       // .../ZeroMatrix
17774       {
17775          {
17776             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17777             using T2 = ZeroMatrix<double,rowMajor>;
17778             using RT = ZeroMatrix<double,rowMajor>;
17779             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17780 
17781             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17782             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17783             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17784          }
17785          {
17786             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17787             using T2 = ZeroMatrix<double,columnMajor>;
17788             using RT = ZeroMatrix<double,columnMajor>;
17789             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17790 
17791             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17792             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17793             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17794          }
17795          {
17796             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17797             using T2 = ZeroMatrix<double,rowMajor>;
17798             using RT = ZeroMatrix<double,rowMajor>;
17799             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17800 
17801             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17802             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17803             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17804          }
17805          {
17806             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17807             using T2 = ZeroMatrix<double,columnMajor>;
17808             using RT = ZeroMatrix<double,columnMajor>;
17809             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17810 
17811             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17812             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17813             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17814          }
17815       }
17816 
17817       // .../SymmetricMatrix<DynamicMatrix> (real)
17818       {
17819          {
17820             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17821             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
17822             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17823             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17824 
17825             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17826             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17827             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17828          }
17829          {
17830             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17831             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
17832             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17833             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17834 
17835             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17836             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17837             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17838          }
17839          {
17840             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17841             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
17842             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17843             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17844 
17845             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17846             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17847             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17848          }
17849          {
17850             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17851             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
17852             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17853             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17854 
17855             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17856             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17857             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17858          }
17859       }
17860 
17861       // .../SymmetricMatrix<DynamicMatrix> (complex)
17862       {
17863          {
17864             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17865             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
17866             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,rowMajor> >;
17867             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17868 
17869             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17870             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17871             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17872          }
17873          {
17874             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17875             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
17876             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,columnMajor> >;
17877             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17878 
17879             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17880             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17881             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17882          }
17883          {
17884             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17885             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
17886             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,rowMajor> >;
17887             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17888 
17889             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17890             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17891             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17892          }
17893          {
17894             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17895             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
17896             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,columnMajor> >;
17897             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17898 
17899             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17900             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17901             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17902          }
17903       }
17904 
17905       // .../SymmetricMatrix<UniformMatrix>
17906       {
17907          {
17908             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17909             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
17910             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17911             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17912 
17913             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17914             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17915             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17916          }
17917          {
17918             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17919             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
17920             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17921             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17922 
17923             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17924             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17925             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17926          }
17927          {
17928             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17929             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
17930             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17931             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17932 
17933             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17934             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17935             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17936          }
17937          {
17938             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17939             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
17940             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
17941             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17942 
17943             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17944             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17945             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17946          }
17947       }
17948 
17949       // .../SymmetricMatrix<ZeroMatrix>
17950       {
17951          {
17952             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17953             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
17954             using RT = ZeroMatrix<double,rowMajor>;
17955             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17956 
17957             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17958             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17959             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17960          }
17961          {
17962             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17963             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
17964             using RT = ZeroMatrix<double,columnMajor>;
17965             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17966 
17967             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17968             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17969             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17970          }
17971          {
17972             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17973             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
17974             using RT = ZeroMatrix<double,rowMajor>;
17975             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17976 
17977             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17978             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17979             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17980          }
17981          {
17982             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
17983             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
17984             using RT = ZeroMatrix<double,columnMajor>;
17985             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
17986 
17987             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
17988             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
17989             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
17990          }
17991       }
17992 
17993       // .../HermitianMatrix<DynamicMatrix> (symmetric)
17994       {
17995          {
17996             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
17997             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
17998             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
17999             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18000 
18001             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18002             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18003             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18004          }
18005          {
18006             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18007             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
18008             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18009             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18010 
18011             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18012             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18013             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18014          }
18015          {
18016             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18017             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
18018             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18019             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18020 
18021             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18022             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18023             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18024          }
18025          {
18026             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18027             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
18028             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18029             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18030 
18031             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18032             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18033             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18034          }
18035       }
18036 
18037       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
18038       {
18039          {
18040             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18041             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18042             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18043             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18044 
18045             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18046             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18047             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18048          }
18049          {
18050             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18051             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
18052             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,columnMajor> >;
18053             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18054 
18055             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18056             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18057             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18058          }
18059          {
18060             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18061             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18062             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18063             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18064 
18065             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18066             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18067             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18068          }
18069          {
18070             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18071             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
18072             using RT = StrictlyLowerMatrix< DynamicMatrix<complex<int>,columnMajor> >;
18073             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18074 
18075             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18076             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18077             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18078          }
18079       }
18080 
18081       // .../LowerMatrix<DynamicMatrix>
18082       {
18083          {
18084             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18085             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
18086             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18087             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18088 
18089             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18090             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18091             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18092          }
18093          {
18094             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18095             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
18096             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18097             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18098 
18099             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18100             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18101             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18102          }
18103          {
18104             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18105             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
18106             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18107             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18108 
18109             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18110             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18111             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18112          }
18113          {
18114             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18115             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
18116             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18117             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18118 
18119             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18120             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18121             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18122          }
18123       }
18124 
18125       // .../UniLowerMatrix<DynamicMatrix>
18126       {
18127          {
18128             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18129             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
18130             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18131             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18132 
18133             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18134             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18135             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18136          }
18137          {
18138             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18139             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
18140             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18141             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18142 
18143             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18144             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18145             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18146          }
18147          {
18148             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18149             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
18150             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18151             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18152 
18153             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18154             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18155             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18156          }
18157          {
18158             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18159             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
18160             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18161             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18162 
18163             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18164             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18165             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18166          }
18167       }
18168 
18169       // .../StrictlyLowerMatrix<DynamicMatrix>
18170       {
18171          {
18172             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18173             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18174             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18175             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18176 
18177             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18178             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18179             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18180          }
18181          {
18182             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18183             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18184             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18185             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18186 
18187             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18188             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18189             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18190          }
18191          {
18192             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18193             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18194             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18195             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18196 
18197             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18198             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18199             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18200          }
18201          {
18202             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18203             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18204             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18205             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18206 
18207             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18208             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18209             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18210          }
18211       }
18212 
18213       // .../UpperMatrix<DynamicMatrix>
18214       {
18215          {
18216             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18217             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
18218             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18219             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18220 
18221             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18222             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18223             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18224          }
18225          {
18226             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18227             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
18228             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18229             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18230 
18231             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18232             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18233             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18234          }
18235          {
18236             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18237             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
18238             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18239             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18240 
18241             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18242             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18243             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18244          }
18245          {
18246             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18247             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
18248             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18249             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18250 
18251             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18252             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18253             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18254          }
18255       }
18256 
18257       // .../UniUpperMatrix<DynamicMatrix>
18258       {
18259          {
18260             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18261             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
18262             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18263             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18264 
18265             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18266             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18267             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18268          }
18269          {
18270             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18271             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
18272             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18273             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18274 
18275             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18276             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18277             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18278          }
18279          {
18280             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18281             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
18282             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18283             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18284 
18285             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18286             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18287             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18288          }
18289          {
18290             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18291             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
18292             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18293             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18294 
18295             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18296             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18297             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18298          }
18299       }
18300 
18301       // .../StrictlyUpperMatrix<DynamicMatrix>
18302       {
18303          {
18304             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18305             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
18306             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18307             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18308 
18309             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18310             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18311             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18312          }
18313          {
18314             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18315             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
18316             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18317             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18318 
18319             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18320             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18321             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18322          }
18323          {
18324             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18325             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
18326             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18327             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18328 
18329             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18330             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18331             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18332          }
18333          {
18334             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18335             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
18336             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18337             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18338 
18339             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18340             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18341             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18342          }
18343       }
18344 
18345       // .../DiagonalMatrix<DynamicMatrix>
18346       {
18347          {
18348             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18349             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
18350             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18351             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18352 
18353             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18354             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18355             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18356          }
18357          {
18358             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
18359             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
18360             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18361             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18362 
18363             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18364             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18365             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18366          }
18367          {
18368             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18369             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
18370             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
18371             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18372 
18373             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18374             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18375             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18376          }
18377          {
18378             using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
18379             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
18380             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
18381             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18382 
18383             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18384             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18385             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18386          }
18387       }
18388    }
18389 
18390    // UpperMatrix<DynamicMatrix>/...
18391    {
18392       // .../StaticMatrix
18393       {
18394          {
18395             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18396             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
18397             using RT = DynamicMatrix<double,rowMajor>;
18398             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18399 
18400             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18401             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18402             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18403          }
18404          {
18405             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18406             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
18407             using RT = DynamicMatrix<double,columnMajor>;
18408             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18409 
18410             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18411             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18412             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18413          }
18414          {
18415             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18416             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
18417             using RT = DynamicMatrix<double,rowMajor>;
18418             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18419 
18420             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18421             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18422             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18423          }
18424          {
18425             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18426             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
18427             using RT = DynamicMatrix<double,columnMajor>;
18428             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18429 
18430             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18431             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18432             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18433          }
18434       }
18435 
18436       // .../HybridMatrix
18437       {
18438          {
18439             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18440             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
18441             using RT = DynamicMatrix<double,rowMajor>;
18442             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18443 
18444             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18445             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18446             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18447          }
18448          {
18449             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18450             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
18451             using RT = DynamicMatrix<double,columnMajor>;
18452             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18453 
18454             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18455             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18456             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18457          }
18458          {
18459             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18460             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
18461             using RT = DynamicMatrix<double,rowMajor>;
18462             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18463 
18464             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18465             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18466             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18467          }
18468          {
18469             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18470             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
18471             using RT = DynamicMatrix<double,columnMajor>;
18472             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18473 
18474             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18475             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18476             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18477          }
18478       }
18479 
18480       // .../DynamicMatrix
18481       {
18482          {
18483             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18484             using T2 = DynamicMatrix<double,rowMajor>;
18485             using RT = DynamicMatrix<double,rowMajor>;
18486             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18487 
18488             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18489             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18490             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18491          }
18492          {
18493             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18494             using T2 = DynamicMatrix<double,columnMajor>;
18495             using RT = DynamicMatrix<double,columnMajor>;
18496             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18497 
18498             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18499             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18500             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18501          }
18502          {
18503             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18504             using T2 = DynamicMatrix<double,rowMajor>;
18505             using RT = DynamicMatrix<double,rowMajor>;
18506             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18507 
18508             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18509             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18510             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18511          }
18512          {
18513             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18514             using T2 = DynamicMatrix<double,columnMajor>;
18515             using RT = DynamicMatrix<double,columnMajor>;
18516             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18517 
18518             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18519             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18520             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18521          }
18522       }
18523 
18524       // .../CustomMatrix
18525       {
18526          {
18527             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18528             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
18529             using RT = DynamicMatrix<double,rowMajor>;
18530             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18531 
18532             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18533             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18534             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18535          }
18536          {
18537             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18538             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
18539             using RT = DynamicMatrix<double,columnMajor>;
18540             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18541 
18542             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18543             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18544             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18545          }
18546          {
18547             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18548             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
18549             using RT = DynamicMatrix<double,rowMajor>;
18550             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18551 
18552             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18553             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18554             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18555          }
18556          {
18557             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18558             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
18559             using RT = DynamicMatrix<double,columnMajor>;
18560             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18561 
18562             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18563             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18564             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18565          }
18566       }
18567 
18568       // .../UniformMatrix
18569       {
18570          {
18571             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18572             using T2 = UniformMatrix<double,rowMajor>;
18573             using RT = DynamicMatrix<double,rowMajor>;
18574             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18575 
18576             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18577             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18578             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18579          }
18580          {
18581             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18582             using T2 = UniformMatrix<double,columnMajor>;
18583             using RT = DynamicMatrix<double,columnMajor>;
18584             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18585 
18586             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18587             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18588             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18589          }
18590          {
18591             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18592             using T2 = UniformMatrix<double,rowMajor>;
18593             using RT = DynamicMatrix<double,rowMajor>;
18594             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18595 
18596             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18597             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18598             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18599          }
18600          {
18601             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18602             using T2 = UniformMatrix<double,columnMajor>;
18603             using RT = DynamicMatrix<double,columnMajor>;
18604             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18605 
18606             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18607             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18608             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18609          }
18610       }
18611 
18612       // .../InitializerMatrix
18613       {
18614          {
18615             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18616             using T2 = InitializerMatrix<double>;
18617             using RT = DynamicMatrix<double,rowMajor>;
18618             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18619 
18620             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18621             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18622             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18623          }
18624          {
18625             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18626             using T2 = InitializerMatrix<double>;
18627             using RT = DynamicMatrix<double,rowMajor>;
18628             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18629 
18630             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18631             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18632             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18633          }
18634       }
18635 
18636       // .../CompressedMatrix
18637       {
18638          {
18639             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18640             using T2 = CompressedMatrix<double,rowMajor>;
18641             using RT = CompressedMatrix<double,rowMajor>;
18642             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18643 
18644             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18645             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18646             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18647          }
18648          {
18649             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18650             using T2 = CompressedMatrix<double,columnMajor>;
18651             using RT = CompressedMatrix<double,columnMajor>;
18652             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18653 
18654             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18655             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18656             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18657          }
18658          {
18659             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18660             using T2 = CompressedMatrix<double,rowMajor>;
18661             using RT = CompressedMatrix<double,rowMajor>;
18662             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18663 
18664             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18665             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18666             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18667          }
18668          {
18669             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18670             using T2 = CompressedMatrix<double,columnMajor>;
18671             using RT = CompressedMatrix<double,columnMajor>;
18672             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18673 
18674             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18675             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18676             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18677          }
18678       }
18679 
18680       // .../IdentityMatrix
18681       {
18682          {
18683             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18684             using T2 = IdentityMatrix<double,rowMajor>;
18685             using RT = UpperMatrix< CompressedMatrix<double,rowMajor> >;
18686             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18687 
18688             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18689             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18690             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18691          }
18692          {
18693             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18694             using T2 = IdentityMatrix<double,columnMajor>;
18695             using RT = UpperMatrix< CompressedMatrix<double,columnMajor> >;
18696             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18697 
18698             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18699             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18700             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18701          }
18702          {
18703             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18704             using T2 = IdentityMatrix<double,rowMajor>;
18705             using RT = UpperMatrix< CompressedMatrix<double,rowMajor> >;
18706             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18707 
18708             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18709             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18710             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18711          }
18712          {
18713             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18714             using T2 = IdentityMatrix<double,columnMajor>;
18715             using RT = UpperMatrix< CompressedMatrix<double,columnMajor> >;
18716             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18717 
18718             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18719             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18720             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18721          }
18722       }
18723 
18724       // .../ZeroMatrix
18725       {
18726          {
18727             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18728             using T2 = ZeroMatrix<double,rowMajor>;
18729             using RT = ZeroMatrix<double,rowMajor>;
18730             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18731 
18732             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18733             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18734             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18735          }
18736          {
18737             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18738             using T2 = ZeroMatrix<double,columnMajor>;
18739             using RT = ZeroMatrix<double,columnMajor>;
18740             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18741 
18742             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18743             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18744             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18745          }
18746          {
18747             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18748             using T2 = ZeroMatrix<double,rowMajor>;
18749             using RT = ZeroMatrix<double,rowMajor>;
18750             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18751 
18752             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18753             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18754             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18755          }
18756          {
18757             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18758             using T2 = ZeroMatrix<double,columnMajor>;
18759             using RT = ZeroMatrix<double,columnMajor>;
18760             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18761 
18762             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18763             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18764             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18765          }
18766       }
18767 
18768       // .../SymmetricMatrix<DynamicMatrix> (real)
18769       {
18770          {
18771             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18772             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
18773             using RT = DynamicMatrix<double,rowMajor>;
18774             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18775 
18776             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18777             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18778             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18779          }
18780          {
18781             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18782             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
18783             using RT = DynamicMatrix<double,columnMajor>;
18784             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18785 
18786             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18787             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18788             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18789          }
18790          {
18791             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18792             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
18793             using RT = DynamicMatrix<double,rowMajor>;
18794             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18795 
18796             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18797             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18798             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18799          }
18800          {
18801             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18802             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
18803             using RT = DynamicMatrix<double,columnMajor>;
18804             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18805 
18806             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18807             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18808             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18809          }
18810       }
18811 
18812       // .../SymmetricMatrix<DynamicMatrix> (complex)
18813       {
18814          {
18815             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18816             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18817             using RT = DynamicMatrix<complex<int>,rowMajor>;
18818             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18819 
18820             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18821             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18822             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18823          }
18824          {
18825             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18826             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
18827             using RT = DynamicMatrix<complex<int>,columnMajor>;
18828             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18829 
18830             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18831             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18832             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18833          }
18834          {
18835             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18836             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18837             using RT = DynamicMatrix<complex<int>,rowMajor>;
18838             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18839 
18840             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18841             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18842             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18843          }
18844          {
18845             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18846             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
18847             using RT = DynamicMatrix<complex<int>,columnMajor>;
18848             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18849 
18850             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18851             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18852             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18853          }
18854       }
18855 
18856       // .../SymmetricMatrix<UniformMatrix>
18857       {
18858          {
18859             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18860             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
18861             using RT = DynamicMatrix<double,rowMajor>;
18862             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18863 
18864             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18865             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18866             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18867          }
18868          {
18869             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18870             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
18871             using RT = DynamicMatrix<double,columnMajor>;
18872             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18873 
18874             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18875             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18876             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18877          }
18878          {
18879             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18880             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
18881             using RT = DynamicMatrix<double,rowMajor>;
18882             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18883 
18884             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18885             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18886             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18887          }
18888          {
18889             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18890             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
18891             using RT = DynamicMatrix<double,columnMajor>;
18892             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18893 
18894             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18895             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18896             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18897          }
18898       }
18899 
18900       // .../SymmetricMatrix<ZeroMatrix>
18901       {
18902          {
18903             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18904             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
18905             using RT = ZeroMatrix<double,rowMajor>;
18906             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18907 
18908             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18909             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18910             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18911          }
18912          {
18913             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18914             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
18915             using RT = ZeroMatrix<double,columnMajor>;
18916             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18917 
18918             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18919             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18920             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18921          }
18922          {
18923             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18924             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
18925             using RT = ZeroMatrix<double,rowMajor>;
18926             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18927 
18928             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18929             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18930             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18931          }
18932          {
18933             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18934             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
18935             using RT = ZeroMatrix<double,columnMajor>;
18936             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18937 
18938             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18939             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18940             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18941          }
18942       }
18943 
18944       // .../HermitianMatrix<DynamicMatrix> (symmetric)
18945       {
18946          {
18947             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18948             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
18949             using RT = DynamicMatrix<double,rowMajor>;
18950             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18951 
18952             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18953             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18954             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18955          }
18956          {
18957             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18958             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
18959             using RT = DynamicMatrix<double,columnMajor>;
18960             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18961 
18962             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18963             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18964             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18965          }
18966          {
18967             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18968             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
18969             using RT = DynamicMatrix<double,rowMajor>;
18970             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18971 
18972             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18973             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18974             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18975          }
18976          {
18977             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
18978             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
18979             using RT = DynamicMatrix<double,columnMajor>;
18980             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18981 
18982             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18983             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18984             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18985          }
18986       }
18987 
18988       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
18989       {
18990          {
18991             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
18992             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
18993             using RT = DynamicMatrix<complex<int>,rowMajor>;
18994             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
18995 
18996             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
18997             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
18998             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
18999          }
19000          {
19001             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19002             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
19003             using RT = DynamicMatrix<complex<int>,columnMajor>;
19004             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19005 
19006             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19007             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19008             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19009          }
19010          {
19011             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19012             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
19013             using RT = DynamicMatrix<complex<int>,rowMajor>;
19014             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19015 
19016             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19017             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19018             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19019          }
19020          {
19021             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19022             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
19023             using RT = DynamicMatrix<complex<int>,columnMajor>;
19024             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19025 
19026             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19027             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19028             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19029          }
19030       }
19031 
19032       // .../LowerMatrix<DynamicMatrix>
19033       {
19034          {
19035             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19036             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
19037             using RT = DynamicMatrix<double,rowMajor>;
19038             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19039 
19040             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19041             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19042             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19043          }
19044          {
19045             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19046             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
19047             using RT = DynamicMatrix<double,columnMajor>;
19048             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19049 
19050             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19051             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19052             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19053          }
19054          {
19055             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19056             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
19057             using RT = DynamicMatrix<double,rowMajor>;
19058             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19059 
19060             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19061             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19062             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19063          }
19064          {
19065             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19066             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
19067             using RT = DynamicMatrix<double,columnMajor>;
19068             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19069 
19070             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19071             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19072             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19073          }
19074       }
19075 
19076       // .../UniLowerMatrix<DynamicMatrix>
19077       {
19078          {
19079             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19080             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
19081             using RT = DynamicMatrix<double,rowMajor>;
19082             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19083 
19084             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19085             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19086             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19087          }
19088          {
19089             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19090             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
19091             using RT = DynamicMatrix<double,columnMajor>;
19092             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19093 
19094             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19095             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19096             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19097          }
19098          {
19099             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19100             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
19101             using RT = DynamicMatrix<double,rowMajor>;
19102             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19103 
19104             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19105             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19106             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19107          }
19108          {
19109             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19110             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
19111             using RT = DynamicMatrix<double,columnMajor>;
19112             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19113 
19114             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19115             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19116             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19117          }
19118       }
19119 
19120       // .../StrictlyLowerMatrix<DynamicMatrix>
19121       {
19122          {
19123             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19124             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
19125             using RT = DynamicMatrix<double,rowMajor>;
19126             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19127 
19128             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19129             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19130             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19131          }
19132          {
19133             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19134             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
19135             using RT = DynamicMatrix<double,columnMajor>;
19136             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19137 
19138             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19139             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19140             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19141          }
19142          {
19143             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19144             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
19145             using RT = DynamicMatrix<double,rowMajor>;
19146             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19147 
19148             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19149             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19150             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19151          }
19152          {
19153             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19154             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
19155             using RT = DynamicMatrix<double,columnMajor>;
19156             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19157 
19158             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19159             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19160             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19161          }
19162       }
19163 
19164       // .../UpperMatrix<DynamicMatrix>
19165       {
19166          {
19167             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19168             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19169             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19170             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19171 
19172             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19173             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19174             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19175          }
19176          {
19177             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19178             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19179             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19180             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19181 
19182             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19183             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19184             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19185          }
19186          {
19187             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19188             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19189             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19190             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19191 
19192             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19193             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19194             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19195          }
19196          {
19197             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19198             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19199             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19200             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19201 
19202             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19203             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19204             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19205          }
19206       }
19207 
19208       // .../UniUpperMatrix<DynamicMatrix>
19209       {
19210          {
19211             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19212             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
19213             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19214             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19215 
19216             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19217             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19218             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19219          }
19220          {
19221             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19222             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
19223             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19224             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19225 
19226             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19227             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19228             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19229          }
19230          {
19231             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19232             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
19233             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19234             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19235 
19236             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19237             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19238             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19239          }
19240          {
19241             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19242             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
19243             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19244             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19245 
19246             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19247             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19248             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19249          }
19250       }
19251 
19252       // .../StrictlyUpperMatrix<DynamicMatrix>
19253       {
19254          {
19255             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19256             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
19257             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
19258             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19259 
19260             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19261             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19262             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19263          }
19264          {
19265             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19266             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
19267             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
19268             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19269 
19270             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19271             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19272             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19273          }
19274          {
19275             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19276             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
19277             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
19278             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19279 
19280             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19281             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19282             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19283          }
19284          {
19285             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19286             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
19287             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
19288             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19289 
19290             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19291             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19292             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19293          }
19294       }
19295 
19296       // .../DiagonalMatrix<DynamicMatrix>
19297       {
19298          {
19299             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19300             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
19301             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19302             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19303 
19304             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19305             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19306             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19307          }
19308          {
19309             using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
19310             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
19311             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19312             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19313 
19314             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19315             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19316             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19317          }
19318          {
19319             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19320             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
19321             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
19322             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19323 
19324             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19325             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19326             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19327          }
19328          {
19329             using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
19330             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
19331             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
19332             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19333 
19334             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19335             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19336             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19337          }
19338       }
19339    }
19340 
19341    // UniUpperMatrix<DynamicMatrix>/...
19342    {
19343       // .../StaticMatrix
19344       {
19345          {
19346             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19347             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
19348             using RT = DynamicMatrix<double,rowMajor>;
19349             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19350 
19351             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19352             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19353             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19354          }
19355          {
19356             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19357             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
19358             using RT = DynamicMatrix<double,columnMajor>;
19359             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19360 
19361             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19362             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19363             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19364          }
19365          {
19366             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19367             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
19368             using RT = DynamicMatrix<double,rowMajor>;
19369             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19370 
19371             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19372             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19373             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19374          }
19375          {
19376             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19377             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
19378             using RT = DynamicMatrix<double,columnMajor>;
19379             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19380 
19381             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19382             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19383             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19384          }
19385       }
19386 
19387       // .../HybridMatrix
19388       {
19389          {
19390             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19391             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
19392             using RT = DynamicMatrix<double,rowMajor>;
19393             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19394 
19395             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19396             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19397             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19398          }
19399          {
19400             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19401             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
19402             using RT = DynamicMatrix<double,columnMajor>;
19403             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19404 
19405             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19406             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19407             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19408          }
19409          {
19410             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19411             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
19412             using RT = DynamicMatrix<double,rowMajor>;
19413             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19414 
19415             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19416             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19417             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19418          }
19419          {
19420             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19421             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
19422             using RT = DynamicMatrix<double,columnMajor>;
19423             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19424 
19425             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19426             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19427             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19428          }
19429       }
19430 
19431       // .../DynamicMatrix
19432       {
19433          {
19434             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19435             using T2 = DynamicMatrix<double,rowMajor>;
19436             using RT = DynamicMatrix<double,rowMajor>;
19437             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19438 
19439             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19440             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19441             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19442          }
19443          {
19444             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19445             using T2 = DynamicMatrix<double,columnMajor>;
19446             using RT = DynamicMatrix<double,columnMajor>;
19447             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19448 
19449             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19450             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19451             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19452          }
19453          {
19454             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19455             using T2 = DynamicMatrix<double,rowMajor>;
19456             using RT = DynamicMatrix<double,rowMajor>;
19457             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19458 
19459             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19460             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19461             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19462          }
19463          {
19464             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19465             using T2 = DynamicMatrix<double,columnMajor>;
19466             using RT = DynamicMatrix<double,columnMajor>;
19467             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19468 
19469             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19470             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19471             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19472          }
19473       }
19474 
19475       // .../CustomMatrix
19476       {
19477          {
19478             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19479             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
19480             using RT = DynamicMatrix<double,rowMajor>;
19481             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19482 
19483             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19484             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19485             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19486          }
19487          {
19488             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19489             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
19490             using RT = DynamicMatrix<double,columnMajor>;
19491             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19492 
19493             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19494             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19495             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19496          }
19497          {
19498             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19499             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
19500             using RT = DynamicMatrix<double,rowMajor>;
19501             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19502 
19503             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19504             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19505             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19506          }
19507          {
19508             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19509             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
19510             using RT = DynamicMatrix<double,columnMajor>;
19511             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19512 
19513             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19514             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19515             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19516          }
19517       }
19518 
19519       // .../UniformMatrix
19520       {
19521          {
19522             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19523             using T2 = UniformMatrix<double,rowMajor>;
19524             using RT = DynamicMatrix<double,rowMajor>;
19525             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19526 
19527             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19528             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19529             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19530          }
19531          {
19532             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19533             using T2 = UniformMatrix<double,columnMajor>;
19534             using RT = DynamicMatrix<double,columnMajor>;
19535             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19536 
19537             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19538             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19539             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19540          }
19541          {
19542             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19543             using T2 = UniformMatrix<double,rowMajor>;
19544             using RT = DynamicMatrix<double,rowMajor>;
19545             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19546 
19547             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19548             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19549             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19550          }
19551          {
19552             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19553             using T2 = UniformMatrix<double,columnMajor>;
19554             using RT = DynamicMatrix<double,columnMajor>;
19555             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19556 
19557             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19558             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19559             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19560          }
19561       }
19562 
19563       // .../InitializerMatrix
19564       {
19565          {
19566             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19567             using T2 = InitializerMatrix<double>;
19568             using RT = DynamicMatrix<double,rowMajor>;
19569             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19570 
19571             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19572             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19573             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19574          }
19575          {
19576             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19577             using T2 = InitializerMatrix<double>;
19578             using RT = DynamicMatrix<double,rowMajor>;
19579             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19580 
19581             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19582             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19583             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19584          }
19585       }
19586 
19587       // .../CompressedMatrix
19588       {
19589          {
19590             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19591             using T2 = CompressedMatrix<double,rowMajor>;
19592             using RT = CompressedMatrix<double,rowMajor>;
19593             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19594 
19595             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19596             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19597             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19598          }
19599          {
19600             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19601             using T2 = CompressedMatrix<double,columnMajor>;
19602             using RT = CompressedMatrix<double,columnMajor>;
19603             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19604 
19605             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19606             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19607             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19608          }
19609          {
19610             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19611             using T2 = CompressedMatrix<double,rowMajor>;
19612             using RT = CompressedMatrix<double,rowMajor>;
19613             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19614 
19615             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19616             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19617             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19618          }
19619          {
19620             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19621             using T2 = CompressedMatrix<double,columnMajor>;
19622             using RT = CompressedMatrix<double,columnMajor>;
19623             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19624 
19625             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19626             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19627             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19628          }
19629       }
19630 
19631       // .../IdentityMatrix
19632       {
19633          {
19634             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19635             using T2 = IdentityMatrix<double,rowMajor>;
19636             using RT = UniUpperMatrix< CompressedMatrix<double,rowMajor> >;
19637             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19638 
19639             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19640             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19641             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19642          }
19643          {
19644             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19645             using T2 = IdentityMatrix<double,columnMajor>;
19646             using RT = UniUpperMatrix< CompressedMatrix<double,columnMajor> >;
19647             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19648 
19649             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19650             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19651             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19652          }
19653          {
19654             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19655             using T2 = IdentityMatrix<double,rowMajor>;
19656             using RT = UniUpperMatrix< CompressedMatrix<double,rowMajor> >;
19657             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19658 
19659             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19660             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19661             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19662          }
19663          {
19664             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19665             using T2 = IdentityMatrix<double,columnMajor>;
19666             using RT = UniUpperMatrix< CompressedMatrix<double,columnMajor> >;
19667             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19668 
19669             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19670             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19671             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19672          }
19673       }
19674 
19675       // .../ZeroMatrix
19676       {
19677          {
19678             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19679             using T2 = ZeroMatrix<double,rowMajor>;
19680             using RT = ZeroMatrix<double,rowMajor>;
19681             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19682 
19683             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19684             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19685             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19686          }
19687          {
19688             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19689             using T2 = ZeroMatrix<double,columnMajor>;
19690             using RT = ZeroMatrix<double,columnMajor>;
19691             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19692 
19693             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19694             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19695             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19696          }
19697          {
19698             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19699             using T2 = ZeroMatrix<double,rowMajor>;
19700             using RT = ZeroMatrix<double,rowMajor>;
19701             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19702 
19703             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19704             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19705             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19706          }
19707          {
19708             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19709             using T2 = ZeroMatrix<double,columnMajor>;
19710             using RT = ZeroMatrix<double,columnMajor>;
19711             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19712 
19713             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19714             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19715             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19716          }
19717       }
19718 
19719       // .../SymmetricMatrix<DynamicMatrix> (real)
19720       {
19721          {
19722             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19723             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
19724             using RT = DynamicMatrix<double,rowMajor>;
19725             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19726 
19727             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19728             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19729             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19730          }
19731          {
19732             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19733             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
19734             using RT = DynamicMatrix<double,columnMajor>;
19735             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19736 
19737             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19738             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19739             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19740          }
19741          {
19742             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19743             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
19744             using RT = DynamicMatrix<double,rowMajor>;
19745             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19746 
19747             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19748             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19749             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19750          }
19751          {
19752             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19753             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
19754             using RT = DynamicMatrix<double,columnMajor>;
19755             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19756 
19757             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19758             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19759             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19760          }
19761       }
19762 
19763       // .../SymmetricMatrix<DynamicMatrix> (complex)
19764       {
19765          {
19766             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19767             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
19768             using RT = DynamicMatrix<complex<int>,rowMajor>;
19769             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19770 
19771             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19772             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19773             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19774          }
19775          {
19776             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19777             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
19778             using RT = DynamicMatrix<complex<int>,columnMajor>;
19779             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19780 
19781             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19782             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19783             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19784          }
19785          {
19786             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19787             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
19788             using RT = DynamicMatrix<complex<int>,rowMajor>;
19789             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19790 
19791             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19792             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19793             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19794          }
19795          {
19796             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19797             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
19798             using RT = DynamicMatrix<complex<int>,columnMajor>;
19799             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19800 
19801             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19802             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19803             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19804          }
19805       }
19806 
19807       // .../SymmetricMatrix<UniformMatrix>
19808       {
19809          {
19810             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19811             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
19812             using RT = DynamicMatrix<double,rowMajor>;
19813             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19814 
19815             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19816             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19817             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19818          }
19819          {
19820             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19821             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
19822             using RT = DynamicMatrix<double,columnMajor>;
19823             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19824 
19825             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19826             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19827             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19828          }
19829          {
19830             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19831             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
19832             using RT = DynamicMatrix<double,rowMajor>;
19833             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19834 
19835             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19836             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19837             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19838          }
19839          {
19840             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19841             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
19842             using RT = DynamicMatrix<double,columnMajor>;
19843             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19844 
19845             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19846             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19847             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19848          }
19849       }
19850 
19851       // .../SymmetricMatrix<ZeroMatrix>
19852       {
19853          {
19854             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19855             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
19856             using RT = ZeroMatrix<double,rowMajor>;
19857             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19858 
19859             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19860             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19861             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19862          }
19863          {
19864             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19865             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
19866             using RT = ZeroMatrix<double,columnMajor>;
19867             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19868 
19869             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19870             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19871             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19872          }
19873          {
19874             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19875             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
19876             using RT = ZeroMatrix<double,rowMajor>;
19877             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19878 
19879             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19880             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19881             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19882          }
19883          {
19884             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19885             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
19886             using RT = ZeroMatrix<double,columnMajor>;
19887             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19888 
19889             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19890             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19891             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19892          }
19893       }
19894 
19895       // .../HermitianMatrix<DynamicMatrix> (symmetric)
19896       {
19897          {
19898             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19899             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
19900             using RT = DynamicMatrix<double,rowMajor>;
19901             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19902 
19903             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19904             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19905             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19906          }
19907          {
19908             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19909             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
19910             using RT = DynamicMatrix<double,columnMajor>;
19911             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19912 
19913             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19914             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19915             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19916          }
19917          {
19918             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19919             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
19920             using RT = DynamicMatrix<double,rowMajor>;
19921             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19922 
19923             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19924             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19925             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19926          }
19927          {
19928             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19929             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
19930             using RT = DynamicMatrix<double,columnMajor>;
19931             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19932 
19933             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19934             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19935             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19936          }
19937       }
19938 
19939       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
19940       {
19941          {
19942             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19943             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
19944             using RT = DynamicMatrix<complex<int>,rowMajor>;
19945             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19946 
19947             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19948             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19949             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19950          }
19951          {
19952             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19953             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
19954             using RT = DynamicMatrix<complex<int>,columnMajor>;
19955             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19956 
19957             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19958             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19959             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19960          }
19961          {
19962             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19963             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
19964             using RT = DynamicMatrix<complex<int>,rowMajor>;
19965             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19966 
19967             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19968             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19969             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19970          }
19971          {
19972             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
19973             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
19974             using RT = DynamicMatrix<complex<int>,columnMajor>;
19975             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19976 
19977             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19978             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19979             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19980          }
19981       }
19982 
19983       // .../LowerMatrix<DynamicMatrix>
19984       {
19985          {
19986             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19987             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
19988             using RT = DynamicMatrix<double,rowMajor>;
19989             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
19990 
19991             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
19992             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
19993             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
19994          }
19995          {
19996             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
19997             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
19998             using RT = DynamicMatrix<double,columnMajor>;
19999             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20000 
20001             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20002             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20003             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20004          }
20005          {
20006             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20007             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
20008             using RT = DynamicMatrix<double,rowMajor>;
20009             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20010 
20011             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20012             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20013             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20014          }
20015          {
20016             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20017             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
20018             using RT = DynamicMatrix<double,columnMajor>;
20019             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20020 
20021             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20022             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20023             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20024          }
20025       }
20026 
20027       // .../UniLowerMatrix<DynamicMatrix>
20028       {
20029          {
20030             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20031             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
20032             using RT = DynamicMatrix<double,rowMajor>;
20033             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20034 
20035             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20036             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20037             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20038          }
20039          {
20040             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20041             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
20042             using RT = DynamicMatrix<double,columnMajor>;
20043             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20044 
20045             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20046             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20047             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20048          }
20049          {
20050             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20051             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
20052             using RT = DynamicMatrix<double,rowMajor>;
20053             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20054 
20055             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20056             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20057             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20058          }
20059          {
20060             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20061             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
20062             using RT = DynamicMatrix<double,columnMajor>;
20063             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20064 
20065             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20066             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20067             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20068          }
20069       }
20070 
20071       // .../StrictlyLowerMatrix<DynamicMatrix>
20072       {
20073          {
20074             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20075             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
20076             using RT = DynamicMatrix<double,rowMajor>;
20077             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20078 
20079             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20080             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20081             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20082          }
20083          {
20084             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20085             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
20086             using RT = DynamicMatrix<double,columnMajor>;
20087             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20088 
20089             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20090             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20091             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20092          }
20093          {
20094             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20095             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
20096             using RT = DynamicMatrix<double,rowMajor>;
20097             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20098 
20099             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20100             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20101             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20102          }
20103          {
20104             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20105             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
20106             using RT = DynamicMatrix<double,columnMajor>;
20107             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20108 
20109             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20110             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20111             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20112          }
20113       }
20114 
20115       // .../UpperMatrix<DynamicMatrix>
20116       {
20117          {
20118             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20119             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
20120             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
20121             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20122 
20123             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20124             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20125             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20126          }
20127          {
20128             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20129             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
20130             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
20131             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20132 
20133             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20134             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20135             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20136          }
20137          {
20138             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20139             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
20140             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
20141             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20142 
20143             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20144             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20145             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20146          }
20147          {
20148             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20149             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
20150             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
20151             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20152 
20153             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20154             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20155             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20156          }
20157       }
20158 
20159       // .../UniUpperMatrix<DynamicMatrix>
20160       {
20161          {
20162             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20163             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
20164             using RT = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
20165             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20166 
20167             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20168             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20169             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20170          }
20171          {
20172             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20173             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
20174             using RT = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
20175             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20176 
20177             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20178             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20179             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20180          }
20181          {
20182             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20183             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
20184             using RT = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
20185             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20186 
20187             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20188             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20189             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20190          }
20191          {
20192             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20193             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
20194             using RT = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
20195             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20196 
20197             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20198             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20199             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20200          }
20201       }
20202 
20203       // .../StrictlyUpperMatrix<DynamicMatrix>
20204       {
20205          {
20206             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20207             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20208             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20209             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20210 
20211             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20212             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20213             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20214          }
20215          {
20216             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20217             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20218             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20219             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20220 
20221             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20222             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20223             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20224          }
20225          {
20226             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20227             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20228             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20229             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20230 
20231             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20232             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20233             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20234          }
20235          {
20236             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20237             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20238             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20239             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20240 
20241             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20242             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20243             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20244          }
20245       }
20246 
20247       // .../DiagonalMatrix<DynamicMatrix>
20248       {
20249          {
20250             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20251             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
20252             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
20253             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20254 
20255             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20256             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20257             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20258          }
20259          {
20260             using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
20261             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
20262             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
20263             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20264 
20265             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20266             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20267             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20268          }
20269          {
20270             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20271             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
20272             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
20273             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20274 
20275             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20276             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20277             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20278          }
20279          {
20280             using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
20281             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
20282             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
20283             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20284 
20285             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20286             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20287             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20288          }
20289       }
20290    }
20291 
20292    // StrictlyUpperMatrix<DynamicMatrix>/...
20293    {
20294       // .../StaticMatrix
20295       {
20296          {
20297             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20298             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
20299             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20300             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20301 
20302             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20303             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20304             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20305          }
20306          {
20307             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20308             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
20309             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20310             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20311 
20312             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20313             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20314             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20315          }
20316          {
20317             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20318             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
20319             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20320             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20321 
20322             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20323             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20324             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20325          }
20326          {
20327             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20328             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
20329             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20330             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20331 
20332             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20333             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20334             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20335          }
20336       }
20337 
20338       // .../HybridMatrix
20339       {
20340          {
20341             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20342             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
20343             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20344             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20345 
20346             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20347             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20348             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20349          }
20350          {
20351             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20352             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
20353             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20354             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20355 
20356             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20357             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20358             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20359          }
20360          {
20361             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20362             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
20363             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20364             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20365 
20366             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20367             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20368             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20369          }
20370          {
20371             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20372             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
20373             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20374             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20375 
20376             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20377             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20378             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20379          }
20380       }
20381 
20382       // .../DynamicMatrix
20383       {
20384          {
20385             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20386             using T2 = DynamicMatrix<double,rowMajor>;
20387             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20388             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20389 
20390             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20391             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20392             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20393          }
20394          {
20395             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20396             using T2 = DynamicMatrix<double,columnMajor>;
20397             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20398             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20399 
20400             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20401             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20402             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20403          }
20404          {
20405             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20406             using T2 = DynamicMatrix<double,rowMajor>;
20407             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20408             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20409 
20410             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20411             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20412             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20413          }
20414          {
20415             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20416             using T2 = DynamicMatrix<double,columnMajor>;
20417             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20418             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20419 
20420             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20421             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20422             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20423          }
20424       }
20425 
20426       // .../CustomMatrix
20427       {
20428          {
20429             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20430             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
20431             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20432             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20433 
20434             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20435             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20436             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20437          }
20438          {
20439             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20440             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
20441             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20442             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20443 
20444             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20445             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20446             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20447          }
20448          {
20449             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20450             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
20451             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20452             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20453 
20454             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20455             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20456             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20457          }
20458          {
20459             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20460             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
20461             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20462             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20463 
20464             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20465             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20466             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20467          }
20468       }
20469 
20470       // .../UniformMatrix
20471       {
20472          {
20473             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20474             using T2 = UniformMatrix<double,rowMajor>;
20475             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20476             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20477 
20478             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20479             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20480             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20481          }
20482          {
20483             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20484             using T2 = UniformMatrix<double,columnMajor>;
20485             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20486             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20487 
20488             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20489             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20490             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20491          }
20492          {
20493             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20494             using T2 = UniformMatrix<double,rowMajor>;
20495             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20496             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20497 
20498             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20499             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20500             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20501          }
20502          {
20503             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20504             using T2 = UniformMatrix<double,columnMajor>;
20505             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20506             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20507 
20508             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20509             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20510             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20511          }
20512       }
20513 
20514       // .../InitializerMatrix
20515       {
20516          {
20517             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20518             using T2 = InitializerMatrix<double>;
20519             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20520             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20521 
20522             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20523             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20524             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20525          }
20526          {
20527             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20528             using T2 = InitializerMatrix<double>;
20529             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20530             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20531 
20532             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20533             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20534             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20535          }
20536       }
20537 
20538       // .../CompressedMatrix
20539       {
20540          {
20541             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20542             using T2 = CompressedMatrix<double,rowMajor>;
20543             using RT = StrictlyUpperMatrix< CompressedMatrix<double,rowMajor> >;
20544             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20545 
20546             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20547             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20548             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20549          }
20550          {
20551             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20552             using T2 = CompressedMatrix<double,columnMajor>;
20553             using RT = StrictlyUpperMatrix< CompressedMatrix<double,columnMajor> >;
20554             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20555 
20556             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20557             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20558             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20559          }
20560          {
20561             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20562             using T2 = CompressedMatrix<double,rowMajor>;
20563             using RT = StrictlyUpperMatrix< CompressedMatrix<double,rowMajor> >;
20564             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20565 
20566             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20567             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20568             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20569          }
20570          {
20571             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20572             using T2 = CompressedMatrix<double,columnMajor>;
20573             using RT = StrictlyUpperMatrix< CompressedMatrix<double,columnMajor> >;
20574             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20575 
20576             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20577             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20578             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20579          }
20580       }
20581 
20582       // .../IdentityMatrix
20583       {
20584          {
20585             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20586             using T2 = IdentityMatrix<double,rowMajor>;
20587             using RT = StrictlyUpperMatrix< CompressedMatrix<double,rowMajor> >;
20588             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20589 
20590             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20591             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20592             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20593          }
20594          {
20595             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20596             using T2 = IdentityMatrix<double,columnMajor>;
20597             using RT = StrictlyUpperMatrix< CompressedMatrix<double,columnMajor> >;
20598             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20599 
20600             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20601             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20602             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20603          }
20604          {
20605             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20606             using T2 = IdentityMatrix<double,rowMajor>;
20607             using RT = StrictlyUpperMatrix< CompressedMatrix<double,rowMajor> >;
20608             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20609 
20610             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20611             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20612             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20613          }
20614          {
20615             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20616             using T2 = IdentityMatrix<double,columnMajor>;
20617             using RT = StrictlyUpperMatrix< CompressedMatrix<double,columnMajor> >;
20618             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20619 
20620             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20621             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20622             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20623          }
20624       }
20625 
20626       // .../ZeroMatrix
20627       {
20628          {
20629             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20630             using T2 = ZeroMatrix<double,rowMajor>;
20631             using RT = ZeroMatrix<double,rowMajor>;
20632             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20633 
20634             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20635             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20636             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20637          }
20638          {
20639             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20640             using T2 = ZeroMatrix<double,columnMajor>;
20641             using RT = ZeroMatrix<double,columnMajor>;
20642             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20643 
20644             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20645             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20646             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20647          }
20648          {
20649             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20650             using T2 = ZeroMatrix<double,rowMajor>;
20651             using RT = ZeroMatrix<double,rowMajor>;
20652             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20653 
20654             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20655             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20656             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20657          }
20658          {
20659             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20660             using T2 = ZeroMatrix<double,columnMajor>;
20661             using RT = ZeroMatrix<double,columnMajor>;
20662             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20663 
20664             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20665             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20666             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20667          }
20668       }
20669 
20670       // .../SymmetricMatrix<DynamicMatrix> (real)
20671       {
20672          {
20673             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20674             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
20675             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20676             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20677 
20678             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20679             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20680             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20681          }
20682          {
20683             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20684             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
20685             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20686             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20687 
20688             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20689             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20690             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20691          }
20692          {
20693             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20694             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
20695             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20696             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20697 
20698             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20699             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20700             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20701          }
20702          {
20703             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20704             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
20705             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20706             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20707 
20708             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20709             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20710             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20711          }
20712       }
20713 
20714       // .../SymmetricMatrix<DynamicMatrix> (complex)
20715       {
20716          {
20717             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20718             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20719             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20720             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20721 
20722             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20723             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20724             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20725          }
20726          {
20727             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20728             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20729             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20730             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20731 
20732             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20733             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20734             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20735          }
20736          {
20737             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20738             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20739             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20740             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20741 
20742             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20743             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20744             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20745          }
20746          {
20747             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20748             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20749             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20750             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20751 
20752             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20753             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20754             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20755          }
20756       }
20757 
20758       // .../SymmetricMatrix<UniformMatrix>
20759       {
20760          {
20761             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20762             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
20763             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20764             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20765 
20766             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20767             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20768             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20769          }
20770          {
20771             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20772             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
20773             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20774             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20775 
20776             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20777             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20778             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20779          }
20780          {
20781             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20782             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
20783             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20784             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20785 
20786             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20787             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20788             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20789          }
20790          {
20791             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20792             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
20793             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20794             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20795 
20796             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20797             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20798             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20799          }
20800       }
20801 
20802       // .../SymmetricMatrix<ZeroMatrix>
20803       {
20804          {
20805             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20806             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
20807             using RT = ZeroMatrix<double,rowMajor>;
20808             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20809 
20810             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20811             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20812             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20813          }
20814          {
20815             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20816             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
20817             using RT = ZeroMatrix<double,columnMajor>;
20818             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20819 
20820             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20821             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20822             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20823          }
20824          {
20825             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20826             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
20827             using RT = ZeroMatrix<double,rowMajor>;
20828             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20829 
20830             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20831             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20832             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20833          }
20834          {
20835             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20836             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
20837             using RT = ZeroMatrix<double,columnMajor>;
20838             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20839 
20840             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20841             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20842             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20843          }
20844       }
20845 
20846       // .../HermitianMatrix<DynamicMatrix> (symmetric)
20847       {
20848          {
20849             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20850             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
20851             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20852             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20853 
20854             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20855             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20856             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20857          }
20858          {
20859             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20860             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
20861             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20862             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20863 
20864             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20865             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20866             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20867          }
20868          {
20869             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20870             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
20871             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20872             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20873 
20874             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20875             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20876             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20877          }
20878          {
20879             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20880             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
20881             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20882             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20883 
20884             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20885             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20886             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20887          }
20888       }
20889 
20890       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
20891       {
20892          {
20893             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20894             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20895             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20896             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20897 
20898             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20899             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20900             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20901          }
20902          {
20903             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20904             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20905             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20906             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20907 
20908             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20909             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20910             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20911          }
20912          {
20913             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20914             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20915             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,rowMajor> >;
20916             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20917 
20918             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20919             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20920             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20921          }
20922          {
20923             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20924             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20925             using RT = StrictlyUpperMatrix< DynamicMatrix<complex<int>,columnMajor> >;
20926             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20927 
20928             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20929             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20930             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20931          }
20932       }
20933 
20934       // .../LowerMatrix<DynamicMatrix>
20935       {
20936          {
20937             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20938             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
20939             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20940             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20941 
20942             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20943             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20944             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20945          }
20946          {
20947             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20948             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
20949             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20950             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20951 
20952             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20953             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20954             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20955          }
20956          {
20957             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20958             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
20959             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20960             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20961 
20962             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20963             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20964             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20965          }
20966          {
20967             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
20968             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
20969             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20970             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20971 
20972             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20973             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20974             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20975          }
20976       }
20977 
20978       // .../UniLowerMatrix<DynamicMatrix>
20979       {
20980          {
20981             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20982             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
20983             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
20984             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20985 
20986             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20987             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20988             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20989          }
20990          {
20991             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
20992             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
20993             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
20994             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
20995 
20996             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
20997             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
20998             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
20999          }
21000          {
21001             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21002             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
21003             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21004             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21005 
21006             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21007             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21008             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21009          }
21010          {
21011             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21012             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
21013             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21014             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21015 
21016             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21017             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21018             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21019          }
21020       }
21021 
21022       // .../StrictlyLowerMatrix<DynamicMatrix>
21023       {
21024          {
21025             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21026             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
21027             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21028             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21029 
21030             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21031             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21032             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21033          }
21034          {
21035             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21036             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
21037             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21038             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21039 
21040             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21041             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21042             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21043          }
21044          {
21045             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21046             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
21047             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21048             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21049 
21050             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21051             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21052             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21053          }
21054          {
21055             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21056             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
21057             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21058             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21059 
21060             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21061             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21062             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21063          }
21064       }
21065 
21066       // .../UpperMatrix<DynamicMatrix>
21067       {
21068          {
21069             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21070             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
21071             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21072             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21073 
21074             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21075             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21076             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21077          }
21078          {
21079             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21080             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
21081             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21082             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21083 
21084             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21085             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21086             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21087          }
21088          {
21089             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21090             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
21091             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21092             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21093 
21094             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21095             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21096             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21097          }
21098          {
21099             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21100             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
21101             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21102             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21103 
21104             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21105             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21106             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21107          }
21108       }
21109 
21110       // .../UniUpperMatrix<DynamicMatrix>
21111       {
21112          {
21113             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21114             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
21115             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21116             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21117 
21118             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21119             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21120             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21121          }
21122          {
21123             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21124             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
21125             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21126             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21127 
21128             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21129             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21130             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21131          }
21132          {
21133             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21134             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
21135             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21136             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21137 
21138             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21139             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21140             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21141          }
21142          {
21143             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21144             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
21145             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21146             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21147 
21148             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21149             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21150             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21151          }
21152       }
21153 
21154       // .../StrictlyUpperMatrix<DynamicMatrix>
21155       {
21156          {
21157             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21158             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21159             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21160             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21161 
21162             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21163             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21164             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21165          }
21166          {
21167             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21168             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21169             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21170             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21171 
21172             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21173             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21174             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21175          }
21176          {
21177             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21178             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21179             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21180             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21181 
21182             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21183             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21184             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21185          }
21186          {
21187             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21188             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21189             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21190             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21191 
21192             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21193             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21194             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21195          }
21196       }
21197 
21198       // .../DiagonalMatrix<DynamicMatrix>
21199       {
21200          {
21201             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21202             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
21203             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21204             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21205 
21206             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21207             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21208             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21209          }
21210          {
21211             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
21212             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
21213             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21214             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21215 
21216             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21217             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21218             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21219          }
21220          {
21221             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21222             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
21223             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
21224             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21225 
21226             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21227             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21228             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21229          }
21230          {
21231             using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
21232             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
21233             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
21234             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21235 
21236             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21237             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21238             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21239          }
21240       }
21241    }
21242 
21243    // DiagonalMatrix<DynamicMatrix>/...
21244    {
21245       // .../StaticMatrix
21246       {
21247          {
21248             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21249             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
21250             using RT = DynamicMatrix<double,rowMajor>;
21251             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21252 
21253             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21254             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21255             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21256          }
21257          {
21258             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21259             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
21260             using RT = DynamicMatrix<double,columnMajor>;
21261             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21262 
21263             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21264             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21265             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21266          }
21267          {
21268             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21269             using T2 = StaticMatrix<double,3UL,3UL,rowMajor>;
21270             using RT = DynamicMatrix<double,rowMajor>;
21271             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21272 
21273             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21274             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21275             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21276          }
21277          {
21278             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21279             using T2 = StaticMatrix<double,3UL,3UL,columnMajor>;
21280             using RT = DynamicMatrix<double,columnMajor>;
21281             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21282 
21283             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21284             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21285             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21286          }
21287       }
21288 
21289       // .../HybridMatrix
21290       {
21291          {
21292             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21293             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
21294             using RT = DynamicMatrix<double,rowMajor>;
21295             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21296 
21297             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21298             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21299             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21300          }
21301          {
21302             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21303             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
21304             using RT = DynamicMatrix<double,columnMajor>;
21305             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21306 
21307             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21308             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21309             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21310          }
21311          {
21312             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21313             using T2 = HybridMatrix<double,8UL,6UL,rowMajor>;
21314             using RT = DynamicMatrix<double,rowMajor>;
21315             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21316 
21317             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21318             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21319             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21320          }
21321          {
21322             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21323             using T2 = HybridMatrix<double,8UL,6UL,columnMajor>;
21324             using RT = DynamicMatrix<double,columnMajor>;
21325             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21326 
21327             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21328             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21329             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21330          }
21331       }
21332 
21333       // .../DynamicMatrix
21334       {
21335          {
21336             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21337             using T2 = DynamicMatrix<double,rowMajor>;
21338             using RT = DynamicMatrix<double,rowMajor>;
21339             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21340 
21341             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21342             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21343             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21344          }
21345          {
21346             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21347             using T2 = DynamicMatrix<double,columnMajor>;
21348             using RT = DynamicMatrix<double,columnMajor>;
21349             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21350 
21351             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21352             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21353             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21354          }
21355          {
21356             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21357             using T2 = DynamicMatrix<double,rowMajor>;
21358             using RT = DynamicMatrix<double,rowMajor>;
21359             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21360 
21361             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21362             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21363             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21364          }
21365          {
21366             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21367             using T2 = DynamicMatrix<double,columnMajor>;
21368             using RT = DynamicMatrix<double,columnMajor>;
21369             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21370 
21371             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21372             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21373             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21374          }
21375       }
21376 
21377       // .../CustomMatrix
21378       {
21379          {
21380             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21381             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
21382             using RT = DynamicMatrix<double,rowMajor>;
21383             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21384 
21385             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21386             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21387             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21388          }
21389          {
21390             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21391             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
21392             using RT = DynamicMatrix<double,columnMajor>;
21393             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21394 
21395             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21396             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21397             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21398          }
21399          {
21400             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21401             using T2 = CustomMatrix<double,unaligned,unpadded,rowMajor>;
21402             using RT = DynamicMatrix<double,rowMajor>;
21403             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21404 
21405             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21406             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21407             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21408          }
21409          {
21410             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21411             using T2 = CustomMatrix<double,unaligned,unpadded,columnMajor>;
21412             using RT = DynamicMatrix<double,columnMajor>;
21413             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21414 
21415             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21416             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21417             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21418          }
21419       }
21420 
21421       // .../UniformMatrix
21422       {
21423          {
21424             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21425             using T2 = UniformMatrix<double,rowMajor>;
21426             using RT = DynamicMatrix<double,rowMajor>;
21427             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21428 
21429             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21430             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21431             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21432          }
21433          {
21434             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21435             using T2 = UniformMatrix<double,columnMajor>;
21436             using RT = DynamicMatrix<double,columnMajor>;
21437             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21438 
21439             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21440             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21441             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21442          }
21443          {
21444             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21445             using T2 = UniformMatrix<double,rowMajor>;
21446             using RT = DynamicMatrix<double,rowMajor>;
21447             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21448 
21449             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21450             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21451             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21452          }
21453          {
21454             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21455             using T2 = UniformMatrix<double,columnMajor>;
21456             using RT = DynamicMatrix<double,columnMajor>;
21457             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21458 
21459             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21460             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21461             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21462          }
21463       }
21464 
21465       // .../InitializerMatrix
21466       {
21467          {
21468             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21469             using T2 = InitializerMatrix<double>;
21470             using RT = DynamicMatrix<double,rowMajor>;
21471             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21472 
21473             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21474             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21475             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21476          }
21477          {
21478             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21479             using T2 = InitializerMatrix<double>;
21480             using RT = DynamicMatrix<double,rowMajor>;
21481             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21482 
21483             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21484             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21485             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21486          }
21487       }
21488 
21489       // .../CompressedMatrix
21490       {
21491          {
21492             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21493             using T2 = CompressedMatrix<double,rowMajor>;
21494             using RT = CompressedMatrix<double,rowMajor>;
21495             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21496 
21497             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21498             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21499             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21500          }
21501          {
21502             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21503             using T2 = CompressedMatrix<double,columnMajor>;
21504             using RT = CompressedMatrix<double,columnMajor>;
21505             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21506 
21507             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21508             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21509             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21510          }
21511          {
21512             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21513             using T2 = CompressedMatrix<double,rowMajor>;
21514             using RT = CompressedMatrix<double,rowMajor>;
21515             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21516 
21517             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21518             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21519             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21520          }
21521          {
21522             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21523             using T2 = CompressedMatrix<double,columnMajor>;
21524             using RT = CompressedMatrix<double,columnMajor>;
21525             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21526 
21527             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21528             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21529             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21530          }
21531       }
21532 
21533       // .../IdentityMatrix
21534       {
21535          {
21536             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21537             using T2 = IdentityMatrix<double,rowMajor>;
21538             using RT = DiagonalMatrix< CompressedMatrix<double,rowMajor> >;
21539             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21540 
21541             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21542             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21543             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21544          }
21545          {
21546             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21547             using T2 = IdentityMatrix<double,columnMajor>;
21548             using RT = DiagonalMatrix< CompressedMatrix<double,columnMajor> >;
21549             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21550 
21551             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21552             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21553             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21554          }
21555          {
21556             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21557             using T2 = IdentityMatrix<double,rowMajor>;
21558             using RT = DiagonalMatrix< CompressedMatrix<double,rowMajor> >;
21559             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21560 
21561             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21562             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21563             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21564          }
21565          {
21566             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21567             using T2 = IdentityMatrix<double,columnMajor>;
21568             using RT = DiagonalMatrix< CompressedMatrix<double,columnMajor> >;
21569             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21570 
21571             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21572             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21573             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21574          }
21575       }
21576 
21577       // .../ZeroMatrix
21578       {
21579          {
21580             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21581             using T2 = ZeroMatrix<double,rowMajor>;
21582             using RT = ZeroMatrix<double,rowMajor>;
21583             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21584 
21585             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21586             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21587             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21588          }
21589          {
21590             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21591             using T2 = ZeroMatrix<double,columnMajor>;
21592             using RT = ZeroMatrix<double,columnMajor>;
21593             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21594 
21595             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21596             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21597             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21598          }
21599          {
21600             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21601             using T2 = ZeroMatrix<double,rowMajor>;
21602             using RT = ZeroMatrix<double,rowMajor>;
21603             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21604 
21605             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21606             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21607             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21608          }
21609          {
21610             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21611             using T2 = ZeroMatrix<double,columnMajor>;
21612             using RT = ZeroMatrix<double,columnMajor>;
21613             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21614 
21615             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21616             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21617             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21618          }
21619       }
21620 
21621       // .../SymmetricMatrix<DynamicMatrix> (real)
21622       {
21623          {
21624             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21625             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21626             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21627             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21628 
21629             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21630             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21631             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21632          }
21633          {
21634             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21635             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21636             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21637             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21638 
21639             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21640             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21641             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21642          }
21643          {
21644             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21645             using T2 = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21646             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21647             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21648 
21649             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21650             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21651             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21652          }
21653          {
21654             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21655             using T2 = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21656             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21657             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21658 
21659             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21660             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21661             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21662          }
21663       }
21664 
21665       // .../SymmetricMatrix<DynamicMatrix> (complex)
21666       {
21667          {
21668             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21669             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21670             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21671             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21672 
21673             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21674             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21675             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21676          }
21677          {
21678             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21679             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21680             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21681             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21682 
21683             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21684             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21685             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21686          }
21687          {
21688             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21689             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21690             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21691             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21692 
21693             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21694             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21695             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21696          }
21697          {
21698             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21699             using T2 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21700             using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21701             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21702 
21703             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21704             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21705             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21706          }
21707       }
21708 
21709       // .../SymmetricMatrix<UniformMatrix>
21710       {
21711          {
21712             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21713             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
21714             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21715             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21716 
21717             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21718             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21719             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21720          }
21721          {
21722             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21723             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
21724             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21725             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21726 
21727             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21728             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21729             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21730          }
21731          {
21732             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21733             using T2 = SymmetricMatrix< UniformMatrix<double,rowMajor> >;
21734             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21735             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21736 
21737             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21738             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21739             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21740          }
21741          {
21742             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21743             using T2 = SymmetricMatrix< UniformMatrix<double,columnMajor> >;
21744             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21745             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21746 
21747             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21748             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21749             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21750          }
21751       }
21752 
21753       // .../SymmetricMatrix<ZeroMatrix>
21754       {
21755          {
21756             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21757             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
21758             using RT = ZeroMatrix<double,rowMajor>;
21759             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21760 
21761             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21762             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21763             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21764          }
21765          {
21766             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21767             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
21768             using RT = ZeroMatrix<double,columnMajor>;
21769             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21770 
21771             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21772             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21773             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21774          }
21775          {
21776             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21777             using T2 = SymmetricMatrix< ZeroMatrix<double,rowMajor> >;
21778             using RT = ZeroMatrix<double,rowMajor>;
21779             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21780 
21781             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21782             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21783             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21784          }
21785          {
21786             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21787             using T2 = SymmetricMatrix< ZeroMatrix<double,columnMajor> >;
21788             using RT = ZeroMatrix<double,columnMajor>;
21789             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21790 
21791             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21792             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21793             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21794          }
21795       }
21796 
21797       // .../HermitianMatrix<DynamicMatrix> (symmetric)
21798       {
21799          {
21800             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21801             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
21802             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21803             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21804 
21805             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21806             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21807             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21808          }
21809          {
21810             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21811             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
21812             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21813             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21814 
21815             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21816             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21817             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21818          }
21819          {
21820             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21821             using T2 = HermitianMatrix< DynamicMatrix<double,rowMajor> >;
21822             using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
21823             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21824 
21825             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21826             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21827             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21828          }
21829          {
21830             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21831             using T2 = HermitianMatrix< DynamicMatrix<double,columnMajor> >;
21832             using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
21833             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21834 
21835             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21836             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21837             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21838          }
21839       }
21840 
21841       // .../HermitianMatrix<DynamicMatrix> (Hermitian)
21842       {
21843          {
21844             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21845             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21846             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21847             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21848 
21849             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21850             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21851             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21852          }
21853          {
21854             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21855             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21856             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21857             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21858 
21859             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21860             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21861             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21862          }
21863          {
21864             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21865             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21866             using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
21867             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21868 
21869             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21870             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21871             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21872          }
21873          {
21874             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21875             using T2 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21876             using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
21877             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21878 
21879             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21880             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21881             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21882          }
21883       }
21884 
21885       // .../LowerMatrix<DynamicMatrix>
21886       {
21887          {
21888             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21889             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
21890             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
21891             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21892 
21893             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21894             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21895             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21896          }
21897          {
21898             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21899             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
21900             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
21901             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21902 
21903             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21904             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21905             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21906          }
21907          {
21908             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21909             using T2 = LowerMatrix< DynamicMatrix<double,rowMajor> >;
21910             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
21911             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21912 
21913             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21914             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21915             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21916          }
21917          {
21918             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21919             using T2 = LowerMatrix< DynamicMatrix<double,columnMajor> >;
21920             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
21921             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21922 
21923             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21924             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21925             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21926          }
21927       }
21928 
21929       // .../UniLowerMatrix<DynamicMatrix>
21930       {
21931          {
21932             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21933             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
21934             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
21935             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21936 
21937             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21938             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21939             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21940          }
21941          {
21942             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21943             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
21944             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
21945             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21946 
21947             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21948             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21949             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21950          }
21951          {
21952             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21953             using T2 = UniLowerMatrix< DynamicMatrix<double,rowMajor> >;
21954             using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
21955             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21956 
21957             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21958             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21959             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21960          }
21961          {
21962             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21963             using T2 = UniLowerMatrix< DynamicMatrix<double,columnMajor> >;
21964             using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
21965             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21966 
21967             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21968             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21969             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21970          }
21971       }
21972 
21973       // .../StrictlyLowerMatrix<DynamicMatrix>
21974       {
21975          {
21976             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21977             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
21978             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
21979             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21980 
21981             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21982             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21983             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21984          }
21985          {
21986             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
21987             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
21988             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
21989             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
21990 
21991             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
21992             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
21993             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
21994          }
21995          {
21996             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
21997             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
21998             using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
21999             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22000 
22001             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22002             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22003             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22004          }
22005          {
22006             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22007             using T2 = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
22008             using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
22009             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22010 
22011             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22012             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22013             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22014          }
22015       }
22016 
22017       // .../UpperMatrix<DynamicMatrix>
22018       {
22019          {
22020             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22021             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
22022             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
22023             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22024 
22025             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22026             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22027             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22028          }
22029          {
22030             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22031             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
22032             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
22033             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22034 
22035             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22036             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22037             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22038          }
22039          {
22040             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22041             using T2 = UpperMatrix< DynamicMatrix<double,rowMajor> >;
22042             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
22043             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22044 
22045             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22046             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22047             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22048          }
22049          {
22050             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22051             using T2 = UpperMatrix< DynamicMatrix<double,columnMajor> >;
22052             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
22053             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22054 
22055             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22056             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22057             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22058          }
22059       }
22060 
22061       // .../UniUpperMatrix<DynamicMatrix>
22062       {
22063          {
22064             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22065             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
22066             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
22067             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22068 
22069             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22070             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22071             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22072          }
22073          {
22074             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22075             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
22076             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
22077             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22078 
22079             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22080             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22081             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22082          }
22083          {
22084             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22085             using T2 = UniUpperMatrix< DynamicMatrix<double,rowMajor> >;
22086             using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
22087             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22088 
22089             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22090             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22091             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22092          }
22093          {
22094             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22095             using T2 = UniUpperMatrix< DynamicMatrix<double,columnMajor> >;
22096             using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
22097             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22098 
22099             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22100             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22101             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22102          }
22103       }
22104 
22105       // .../StrictlyUpperMatrix<DynamicMatrix>
22106       {
22107          {
22108             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22109             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
22110             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
22111             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22112 
22113             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22114             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22115             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22116          }
22117          {
22118             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22119             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
22120             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
22121             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22122 
22123             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22124             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22125             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22126          }
22127          {
22128             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22129             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
22130             using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
22131             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22132 
22133             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22134             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22135             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22136          }
22137          {
22138             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22139             using T2 = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
22140             using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
22141             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22142 
22143             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22144             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22145             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22146          }
22147       }
22148 
22149       // .../DiagonalMatrix<DynamicMatrix>
22150       {
22151          {
22152             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22153             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
22154             using RT = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
22155             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22156 
22157             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22158             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22159             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22160          }
22161          {
22162             using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
22163             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
22164             using RT = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
22165             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22166 
22167             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22168             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22169             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22170          }
22171          {
22172             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22173             using T2 = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
22174             using RT = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
22175             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22176 
22177             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22178             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22179             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22180          }
22181          {
22182             using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
22183             using T2 = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
22184             using RT = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
22185             static_assert( IsSame_v< KronTrait_t<T1,T2>, RT >, "Non-matching type detected" );
22186 
22187             using Expr = RemoveCVRef_t< decltype( kron( std::declval<T1>(), std::declval<T2>() ) ) >;
22188             static_assert( IsSame_v< ResultType_t<Expr>, RT >, "Non-matching type detected" );
22189             static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
22190          }
22191       }
22192    }
22193 }
22194 //*************************************************************************************************
22195 
22196 } // namespace krontrait
22197 
22198 } // namespace traits
22199 
22200 } // namespace mathtest
22201 
22202 } // namespace blazetest
22203 
22204 
22205 
22206 
22207 //=================================================================================================
22208 //
22209 //  MAIN FUNCTION
22210 //
22211 //=================================================================================================
22212 
22213 //*************************************************************************************************
main()22214 int main()
22215 {
22216    std::cout << "   Running KronTrait class test..." << std::endl;
22217 
22218    try
22219    {
22220       RUN_KRONTRAIT_CLASS_TEST;
22221    }
22222    catch( std::exception& ex ) {
22223       std::cerr << "\n\n ERROR DETECTED during KronTrait class test:\n"
22224                 << ex.what() << "\n";
22225       return EXIT_FAILURE;
22226    }
22227 
22228    return EXIT_SUCCESS;
22229 }
22230 //*************************************************************************************************
22231