1 //=================================================================================================
2 /*!
3 // \file src/mathtest/traits/divtrait/ClassTest.cpp
4 // \brief Source file for the DivTrait class test
5 //
6 // Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved
7 //
8 // This file is part of the Blaze library. You can redistribute it and/or modify it under
9 // the terms of the New (Revised) BSD License. Redistribution and use in source and binary
10 // forms, with or without modification, are permitted provided that the following conditions
11 // are met:
12 //
13 // 1. Redistributions of source code must retain the above copyright notice, this list of
14 // conditions and the following disclaimer.
15 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
16 // of conditions and the following disclaimer in the documentation and/or other materials
17 // provided with the distribution.
18 // 3. Neither the names of the Blaze development group nor the names of its contributors
19 // may be used to endorse or promote products derived from this software without specific
20 // prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 // SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 // BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
31 // DAMAGE.
32 */
33 //=================================================================================================
34
35
36 //*************************************************************************************************
37 // Includes
38 //*************************************************************************************************
39
40 #include <cstdlib>
41 #include <iostream>
42 #include <utility>
43 #include <blaze/math/CompressedMatrix.h>
44 #include <blaze/math/CompressedVector.h>
45 #include <blaze/math/CustomMatrix.h>
46 #include <blaze/math/CustomVector.h>
47 #include <blaze/math/DynamicMatrix.h>
48 #include <blaze/math/DynamicVector.h>
49 #include <blaze/math/HermitianMatrix.h>
50 #include <blaze/math/HybridMatrix.h>
51 #include <blaze/math/HybridVector.h>
52 #include <blaze/math/IdentityMatrix.h>
53 #include <blaze/math/InitializerMatrix.h>
54 #include <blaze/math/InitializerVector.h>
55 #include <blaze/math/LowerMatrix.h>
56 #include <blaze/math/StaticMatrix.h>
57 #include <blaze/math/StaticVector.h>
58 #include <blaze/math/StrictlyLowerMatrix.h>
59 #include <blaze/math/StrictlyUpperMatrix.h>
60 #include <blaze/math/SymmetricMatrix.h>
61 #include <blaze/math/traits/DivTrait.h>
62 #include <blaze/math/typetraits/StorageOrder.h>
63 #include <blaze/math/typetraits/TransposeFlag.h>
64 #include <blaze/math/UniformMatrix.h>
65 #include <blaze/math/UniformVector.h>
66 #include <blaze/math/UniLowerMatrix.h>
67 #include <blaze/math/UniUpperMatrix.h>
68 #include <blaze/math/UpperMatrix.h>
69 #include <blaze/math/ZeroMatrix.h>
70 #include <blaze/math/ZeroVector.h>
71 #include <blaze/util/Complex.h>
72 #include <blaze/util/typetraits/IsSame.h>
73 #include <blaze/util/typetraits/RemoveCVRef.h>
74 #include <blazetest/mathtest/traits/divtrait/ClassTest.h>
75
76
77 namespace blazetest {
78
79 namespace mathtest {
80
81 namespace traits {
82
83 namespace divtrait {
84
85 //=================================================================================================
86 //
87 // CONSTRUCTORS
88 //
89 //=================================================================================================
90
91 //*************************************************************************************************
92 /*!\brief Constructor for the DivTrait class test.
93 //
94 // \exception std::runtime_error Error detected.
95 */
ClassTest()96 ClassTest::ClassTest()
97 {
98 testScalarScalarDivision();
99 testVectorScalarDivision();
100 testMatrixScalarDivision();
101 testVectorVectorDivision();
102 }
103 //*************************************************************************************************
104
105
106
107
108 //=================================================================================================
109 //
110 // TEST FUNCTIONS
111 //
112 //=================================================================================================
113
114 //*************************************************************************************************
115 /*!\brief Test of the 'DivTrait' class template for scalar/scalar division operations.
116 //
117 // \return void
118 // \exception std::runtime_error Error detected.
119 //
120 // This function performs a compile time test of the 'DivTrait' class template for scalar/scalar
121 // division operations. In case an error is detected, a compilation error is created.
122 */
testScalarScalarDivision()123 void ClassTest::testScalarScalarDivision()
124 {
125 using namespace blaze;
126
127
128 // short/...
129 {
130 // .../short
131 {
132 using T1 = short;
133 using T2 = short;
134 using RT = short;
135 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
136 }
137
138 // .../int
139 {
140 using T1 = short;
141 using T2 = int;
142 using RT = int;
143 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
144 }
145
146 // .../float
147 {
148 using T1 = short;
149 using T2 = float;
150 using RT = float;
151 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
152 }
153
154 // .../double
155 {
156 using T1 = short;
157 using T2 = double;
158 using RT = double;
159 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
160 }
161 }
162
163 // int/...
164 {
165 // .../short
166 {
167 using T1 = int;
168 using T2 = short;
169 using RT = int;
170 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
171 }
172
173 // .../int
174 {
175 using T1 = int;
176 using T2 = int;
177 using RT = int;
178 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
179 }
180
181 // .../float
182 {
183 using T1 = int;
184 using T2 = float;
185 using RT = float;
186 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
187 }
188
189 // .../double
190 {
191 using T1 = int;
192 using T2 = double;
193 using RT = double;
194 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
195 }
196 }
197
198 // float/...
199 {
200 // .../short
201 {
202 using T1 = float;
203 using T2 = short;
204 using RT = float;
205 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
206 }
207
208 // .../int
209 {
210 using T1 = float;
211 using T2 = int;
212 using RT = float;
213 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
214 }
215
216 // .../float
217 {
218 using T1 = float;
219 using T2 = float;
220 using RT = float;
221 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
222 }
223
224 // .../double
225 {
226 using T1 = float;
227 using T2 = double;
228 using RT = double;
229 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
230 }
231
232 // .../complex<float>
233 {
234 using T1 = float;
235 using T2 = complex<float>;
236 using RT = complex<float>;
237 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
238 }
239 }
240
241 // double/...
242 {
243 // .../short
244 {
245 using T1 = double;
246 using T2 = short;
247 using RT = double;
248 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
249 }
250
251 // .../int
252 {
253 using T1 = double;
254 using T2 = int;
255 using RT = double;
256 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
257 }
258
259 // .../float
260 {
261 using T1 = double;
262 using T2 = float;
263 using RT = double;
264 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
265 }
266
267 // .../double
268 {
269 using T1 = double;
270 using T2 = double;
271 using RT = double;
272 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
273 }
274
275 // .../complex<double>
276 {
277 using T1 = double;
278 using T2 = complex<double>;
279 using RT = complex<double>;
280 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
281 }
282 }
283
284 // complex<double>/...
285 {
286 // .../double
287 {
288 using T1 = complex<double>;
289 using T2 = double;
290 using RT = complex<double>;
291 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
292 }
293
294 // .../complex<double>
295 {
296 using T1 = complex<double>;
297 using T2 = complex<double>;
298 using RT = complex<double>;
299 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
300 }
301 }
302 }
303 //*************************************************************************************************
304
305
306 //*************************************************************************************************
307 /*!\brief Test of the 'DivTrait' class template for vector/scalar division operations.
308 //
309 // \return void
310 // \exception std::runtime_error Error detected.
311 //
312 // This function performs a compile time test of the 'DivTrait' class template for vector/scalar
313 // division operations. In case an error is detected, a compilation error is created.
314 */
testVectorScalarDivision()315 void ClassTest::testVectorScalarDivision()
316 {
317 using namespace blaze;
318
319
320 // StaticVector
321 {
322 {
323 using T1 = StaticVector<int,3UL,columnVector>;
324 using T2 = double;
325 using RT = StaticVector<double,3UL,columnVector>;
326 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
327
328 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
329 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
330 }
331 {
332 using T1 = StaticVector<int,3UL,rowVector>;
333 using T2 = double;
334 using RT = StaticVector<double,3UL,rowVector>;
335 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
336
337 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
338 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
339 }
340 }
341
342 // HybridVector
343 {
344 {
345 using T1 = HybridVector<int,5UL,columnVector>;
346 using T2 = double;
347 using RT = HybridVector<double,5UL,columnVector>;
348 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
349
350 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
351 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
352 }
353 {
354 using T1 = HybridVector<int,5UL,rowVector>;
355 using T2 = double;
356 using RT = HybridVector<double,5UL,rowVector>;
357 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
358
359 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
360 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
361 }
362 }
363
364 // DynamicVector
365 {
366 {
367 using T1 = DynamicVector<int,columnVector>;
368 using T2 = double;
369 using RT = DynamicVector<double,columnVector>;
370 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
371
372 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
373 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
374 }
375 {
376 using T1 = DynamicVector<int,rowVector>;
377 using T2 = double;
378 using RT = DynamicVector<double,rowVector>;
379 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
380
381 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
382 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
383 }
384 }
385
386 // CustomVector
387 {
388 {
389 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
390 using T2 = double;
391 using RT = DynamicVector<double,columnVector>;
392 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
393
394 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
395 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
396 }
397 {
398 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
399 using T2 = double;
400 using RT = DynamicVector<double,rowVector>;
401 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
402
403 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
404 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
405 }
406 }
407
408 // UniformVector
409 {
410 {
411 using T1 = UniformVector<int,columnVector>;
412 using T2 = double;
413 using RT = UniformVector<double,columnVector>;
414 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
415
416 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
417 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
418 }
419 {
420 using T1 = UniformVector<int,rowVector>;
421 using T2 = double;
422 using RT = UniformVector<double,rowVector>;
423 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
424
425 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
426 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
427 }
428 }
429
430 // InitializerVector
431 {
432 {
433 using T1 = InitializerVector<int,columnVector>;
434 using T2 = double;
435 using RT = DynamicVector<double,columnVector>;
436 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
437
438 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
439 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
440 }
441 {
442 using T1 = InitializerVector<int,rowVector>;
443 using T2 = double;
444 using RT = DynamicVector<double,rowVector>;
445 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
446
447 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
448 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
449 }
450 }
451
452 // CompressedVector
453 {
454 {
455 using T1 = CompressedVector<int,columnVector>;
456 using T2 = double;
457 using RT = CompressedVector<double,columnVector>;
458 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
459
460 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
461 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
462 }
463 {
464 using T1 = CompressedVector<int,rowVector>;
465 using T2 = double;
466 using RT = CompressedVector<double,rowVector>;
467 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
468
469 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
470 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
471 }
472 }
473
474 // ZeroVector
475 {
476 {
477 using T1 = ZeroVector<int,columnVector>;
478 using T2 = double;
479 using RT = ZeroVector<double,columnVector>;
480 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
481
482 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
483 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
484 }
485 {
486 using T1 = ZeroVector<int,rowVector>;
487 using T2 = double;
488 using RT = ZeroVector<double,rowVector>;
489 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
490
491 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
492 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
493 }
494 }
495 }
496 //*************************************************************************************************
497
498
499 //*************************************************************************************************
500 /*!\brief Test of the 'DivTrait' class template for matrix/scalar division operations.
501 //
502 // \return void
503 // \exception std::runtime_error Error detected.
504 //
505 // This function performs a compile time test of the 'DivTrait' class template for matrix/scalar
506 // division operations. In case an error is detected, a compilation error is created.
507 */
testMatrixScalarDivision()508 void ClassTest::testMatrixScalarDivision()
509 {
510 using namespace blaze;
511
512
513 // StaticMatrix
514 {
515 {
516 using T1 = StaticMatrix<int,3UL,5UL,rowMajor>;
517 using T2 = double;
518 using RT = StaticMatrix<double,3UL,5UL,rowMajor>;
519 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
520
521 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
522 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
523 }
524 {
525 using T1 = StaticMatrix<int,3UL,5UL,columnMajor>;
526 using T2 = double;
527 using RT = StaticMatrix<double,3UL,5UL,columnMajor>;
528 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
529
530 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
531 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
532 }
533 }
534
535 // HybridMatrix
536 {
537 {
538 using T1 = HybridMatrix<int,5UL,7UL,rowMajor>;
539 using T2 = double;
540 using RT = HybridMatrix<double,5UL,7UL,rowMajor>;
541 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
542
543 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
544 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
545 }
546 {
547 using T1 = HybridMatrix<int,5UL,7UL,columnMajor>;
548 using T2 = double;
549 using RT = HybridMatrix<double,5UL,7UL,columnMajor>;
550 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
551
552 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
553 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
554 }
555 }
556
557 // DynamicMatrix
558 {
559 {
560 using T1 = DynamicMatrix<int,rowMajor>;
561 using T2 = double;
562 using RT = DynamicMatrix<double,rowMajor>;
563 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
564
565 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
566 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
567 }
568 {
569 using T1 = DynamicMatrix<int,columnMajor>;
570 using T2 = double;
571 using RT = DynamicMatrix<double,columnMajor>;
572 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
573
574 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
575 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
576 }
577 }
578
579 // CustomMatrix
580 {
581 {
582 using T1 = CustomMatrix<int,unaligned,unpadded,rowMajor>;
583 using T2 = double;
584 using RT = DynamicMatrix<double,rowMajor>;
585 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
586
587 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
588 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
589 }
590 {
591 using T1 = CustomMatrix<int,unaligned,unpadded,columnMajor>;
592 using T2 = double;
593 using RT = DynamicMatrix<double,columnMajor>;
594 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
595
596 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
597 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
598 }
599 }
600
601 // UniformMatrix
602 {
603 {
604 using T1 = UniformMatrix<int,rowMajor>;
605 using T2 = double;
606 using RT = UniformMatrix<double,rowMajor>;
607 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
608
609 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
610 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
611 }
612 {
613 using T1 = UniformMatrix<int,columnMajor>;
614 using T2 = double;
615 using RT = UniformMatrix<double,columnMajor>;
616 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
617
618 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
619 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
620 }
621 }
622
623 // InitializerMatrix
624 {
625 {
626 using T1 = InitializerMatrix<int>;
627 using T2 = double;
628 using RT = DynamicMatrix<double,rowMajor>;
629 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
630
631 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
632 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
633 }
634 }
635
636 // CompressedMatrix
637 {
638 {
639 using T1 = CompressedMatrix<int,rowMajor>;
640 using T2 = double;
641 using RT = CompressedMatrix<double,rowMajor>;
642 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
643
644 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
645 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
646 }
647 {
648 using T1 = CompressedMatrix<int,columnMajor>;
649 using T2 = double;
650 using RT = CompressedMatrix<double,columnMajor>;
651 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
652
653 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
654 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
655 }
656 }
657
658 // IdentityMatrix
659 {
660 {
661 using T1 = IdentityMatrix<int,rowMajor>;
662 using T2 = double;
663 using RT = DiagonalMatrix< CompressedMatrix<double,rowMajor> >;
664 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
665
666 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
667 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
668 }
669 {
670 using T1 = IdentityMatrix<int,columnMajor>;
671 using T2 = double;
672 using RT = DiagonalMatrix< CompressedMatrix<double,columnMajor> >;
673 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
674
675 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
676 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
677 }
678 }
679
680 // ZeroMatrix
681 {
682 {
683 using T1 = ZeroMatrix<int,rowMajor>;
684 using T2 = double;
685 using RT = ZeroMatrix<double,rowMajor>;
686 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
687
688 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
689 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
690 }
691 {
692 using T1 = ZeroMatrix<int,columnMajor>;
693 using T2 = double;
694 using RT = ZeroMatrix<double,columnMajor>;
695 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
696
697 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
698 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
699 }
700 }
701
702 // SymmetricMatrix (real)
703 {
704 {
705 using T1 = SymmetricMatrix< DynamicMatrix<int,rowMajor> >;
706 using T2 = double;
707 using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
708 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
709
710 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
711 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
712 }
713 {
714 using T1 = SymmetricMatrix< DynamicMatrix<int,columnMajor> >;
715 using T2 = double;
716 using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
717 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
718
719 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
720 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
721 }
722 }
723
724 // SymmetricMatrix (complex)
725 {
726 {
727 using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
728 using T2 = int;
729 using RT = SymmetricMatrix< DynamicMatrix<complex<int>,rowMajor> >;
730 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
731
732 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
733 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
734 }
735 {
736 using T1 = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
737 using T2 = int;
738 using RT = SymmetricMatrix< DynamicMatrix<complex<int>,columnMajor> >;
739 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
740
741 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
742 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
743 }
744 }
745
746 // HermitianMatrix (symmetric)
747 {
748 {
749 using T1 = HermitianMatrix< DynamicMatrix<int,rowMajor> >;
750 using T2 = double;
751 using RT = SymmetricMatrix< DynamicMatrix<double,rowMajor> >;
752 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
753
754 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
755 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
756 }
757 {
758 using T1 = HermitianMatrix< DynamicMatrix<int,columnMajor> >;
759 using T2 = double;
760 using RT = SymmetricMatrix< DynamicMatrix<double,columnMajor> >;
761 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
762
763 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
764 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
765 }
766 }
767
768 // HermitianMatrix (Hermitian)
769 {
770 {
771 using T1 = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
772 using T2 = int;
773 using RT = HermitianMatrix< DynamicMatrix<complex<int>,rowMajor> >;
774 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
775
776 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
777 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
778 }
779 {
780 using T1 = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
781 using T2 = int;
782 using RT = HermitianMatrix< DynamicMatrix<complex<int>,columnMajor> >;
783 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
784
785 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
786 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
787 }
788 }
789
790 // LowerMatrix
791 {
792 {
793 using T1 = LowerMatrix< DynamicMatrix<int,rowMajor> >;
794 using T2 = double;
795 using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
796 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
797
798 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
799 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
800 }
801 {
802 using T1 = LowerMatrix< DynamicMatrix<int,columnMajor> >;
803 using T2 = double;
804 using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
805 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
806
807 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
808 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
809 }
810 }
811
812 // UniLowerMatrix
813 {
814 {
815 using T1 = UniLowerMatrix< DynamicMatrix<int,rowMajor> >;
816 using T2 = double;
817 using RT = LowerMatrix< DynamicMatrix<double,rowMajor> >;
818 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
819
820 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
821 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
822 }
823 {
824 using T1 = UniLowerMatrix< DynamicMatrix<int,columnMajor> >;
825 using T2 = double;
826 using RT = LowerMatrix< DynamicMatrix<double,columnMajor> >;
827 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
828
829 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
830 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
831 }
832 }
833
834 // StrictlyLowerMatrix
835 {
836 {
837 using T1 = StrictlyLowerMatrix< DynamicMatrix<int,rowMajor> >;
838 using T2 = double;
839 using RT = StrictlyLowerMatrix< DynamicMatrix<double,rowMajor> >;
840 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
841
842 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
843 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
844 }
845 {
846 using T1 = StrictlyLowerMatrix< DynamicMatrix<int,columnMajor> >;
847 using T2 = double;
848 using RT = StrictlyLowerMatrix< DynamicMatrix<double,columnMajor> >;
849 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
850
851 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
852 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
853 }
854 }
855
856 // UpperMatrix
857 {
858 {
859 using T1 = UpperMatrix< DynamicMatrix<int,rowMajor> >;
860 using T2 = double;
861 using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
862 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
863
864 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
865 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
866 }
867 {
868 using T1 = UpperMatrix< DynamicMatrix<int,columnMajor> >;
869 using T2 = double;
870 using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
871 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
872
873 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
874 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
875 }
876 }
877
878 // UniUpperMatrix
879 {
880 {
881 using T1 = UniUpperMatrix< DynamicMatrix<int,rowMajor> >;
882 using T2 = double;
883 using RT = UpperMatrix< DynamicMatrix<double,rowMajor> >;
884 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
885
886 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
887 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
888 }
889 {
890 using T1 = UniUpperMatrix< DynamicMatrix<int,columnMajor> >;
891 using T2 = double;
892 using RT = UpperMatrix< DynamicMatrix<double,columnMajor> >;
893 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
894
895 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
896 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
897 }
898 }
899
900 // StrictlyUpperMatrix
901 {
902 {
903 using T1 = StrictlyUpperMatrix< DynamicMatrix<int,rowMajor> >;
904 using T2 = double;
905 using RT = StrictlyUpperMatrix< DynamicMatrix<double,rowMajor> >;
906 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
907
908 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
909 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
910 }
911 {
912 using T1 = StrictlyUpperMatrix< DynamicMatrix<int,columnMajor> >;
913 using T2 = double;
914 using RT = StrictlyUpperMatrix< DynamicMatrix<double,columnMajor> >;
915 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
916
917 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
918 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
919 }
920 }
921
922 // DiagonalMatrix
923 {
924 {
925 using T1 = DiagonalMatrix< DynamicMatrix<int,rowMajor> >;
926 using T2 = double;
927 using RT = DiagonalMatrix< DynamicMatrix<double,rowMajor> >;
928 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
929
930 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
931 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
932 }
933 {
934 using T1 = DiagonalMatrix< DynamicMatrix<int,columnMajor> >;
935 using T2 = double;
936 using RT = DiagonalMatrix< DynamicMatrix<double,columnMajor> >;
937 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
938
939 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
940 static_assert( StorageOrder_v<Expr> == StorageOrder_v<RT>, "Non-matching storage order detected" );
941 }
942 }
943 }
944 //*************************************************************************************************
945
946
947 //*************************************************************************************************
948 /*!\brief Test of the 'DivTrait' class template for vector/vector division operations.
949 //
950 // \return void
951 // \exception std::runtime_error Error detected.
952 //
953 // This function performs a compile time test of the 'DivTrait' class template for vector/vector
954 // division operations. In case an error is detected, a compilation error is created.
955 */
testVectorVectorDivision()956 void ClassTest::testVectorVectorDivision()
957 {
958 using namespace blaze;
959
960
961 // StaticVector/...
962 {
963 // .../StaticVector
964 {
965 {
966 using T1 = StaticVector<int,3UL,columnVector>;
967 using T2 = StaticVector<double,3UL,columnVector>;
968 using RT = StaticVector<double,3UL,columnVector>;
969 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
970
971 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
972 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
973 }
974 {
975 using T1 = StaticVector<int,3UL,rowVector>;
976 using T2 = StaticVector<double,3UL,rowVector>;
977 using RT = StaticVector<double,3UL,rowVector>;
978 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
979
980 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
981 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
982 }
983 }
984
985 // .../HybridVector
986 {
987 {
988 using T1 = StaticVector<int,3UL,columnVector>;
989 using T2 = HybridVector<double,5UL,columnVector>;
990 using RT = StaticVector<double,3UL,columnVector>;
991 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
992
993 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
994 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
995 }
996 {
997 using T1 = StaticVector<int,3UL,rowVector>;
998 using T2 = HybridVector<double,5UL,rowVector>;
999 using RT = StaticVector<double,3UL,rowVector>;
1000 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1001
1002 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1003 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1004 }
1005 }
1006
1007 // .../DynamicVector
1008 {
1009 {
1010 using T1 = StaticVector<int,3UL,columnVector>;
1011 using T2 = DynamicVector<double,columnVector>;
1012 using RT = StaticVector<double,3UL,columnVector>;
1013 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1014
1015 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1016 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1017 }
1018 {
1019 using T1 = StaticVector<int,3UL,rowVector>;
1020 using T2 = DynamicVector<double,rowVector>;
1021 using RT = StaticVector<double,3UL,rowVector>;
1022 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1023
1024 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1025 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1026 }
1027 }
1028
1029 // .../CustomVector
1030 {
1031 {
1032 using T1 = StaticVector<int,3UL,columnVector>;
1033 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1034 using RT = StaticVector<double,3UL,columnVector>;
1035 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1036
1037 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1038 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1039 }
1040 {
1041 using T1 = StaticVector<int,3UL,rowVector>;
1042 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1043 using RT = StaticVector<double,3UL,rowVector>;
1044 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1045
1046 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1047 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1048 }
1049 }
1050
1051 // .../DynamicVector
1052 {
1053 {
1054 using T1 = StaticVector<int,3UL,columnVector>;
1055 using T2 = UniformVector<double,columnVector>;
1056 using RT = StaticVector<double,3UL,columnVector>;
1057 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1058
1059 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1060 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1061 }
1062 {
1063 using T1 = StaticVector<int,3UL,rowVector>;
1064 using T2 = UniformVector<double,rowVector>;
1065 using RT = StaticVector<double,3UL,rowVector>;
1066 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1067
1068 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1069 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1070 }
1071 }
1072
1073 // .../InitializerVector
1074 {
1075 {
1076 using T1 = StaticVector<int,3UL,columnVector>;
1077 using T2 = InitializerVector<double,columnVector>;
1078 using RT = StaticVector<double,3UL,columnVector>;
1079 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1080
1081 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1082 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1083 }
1084 {
1085 using T1 = StaticVector<int,3UL,rowVector>;
1086 using T2 = InitializerVector<double,rowVector>;
1087 using RT = StaticVector<double,3UL,rowVector>;
1088 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1089
1090 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1091 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1092 }
1093 }
1094 }
1095
1096 // HybridVector/...
1097 {
1098 // .../StaticVector
1099 {
1100 {
1101 using T1 = HybridVector<int,5UL,columnVector>;
1102 using T2 = StaticVector<double,3UL,columnVector>;
1103 using RT = StaticVector<double,3UL,columnVector>;
1104 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1105
1106 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1107 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1108 }
1109 {
1110 using T1 = HybridVector<int,5UL,rowVector>;
1111 using T2 = StaticVector<double,3UL,rowVector>;
1112 using RT = StaticVector<double,3UL,rowVector>;
1113 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1114
1115 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1116 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1117 }
1118 }
1119
1120 // .../HybridVector
1121 {
1122 {
1123 using T1 = HybridVector<int,5UL,columnVector>;
1124 using T2 = HybridVector<double,7UL,columnVector>;
1125 using RT = HybridVector<double,5UL,columnVector>;
1126 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1127
1128 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1129 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1130 }
1131 {
1132 using T1 = HybridVector<int,5UL,rowVector>;
1133 using T2 = HybridVector<double,7UL,rowVector>;
1134 using RT = HybridVector<double,5UL,rowVector>;
1135 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1136
1137 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1138 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1139 }
1140 }
1141
1142 // .../DynamicVector
1143 {
1144 {
1145 using T1 = HybridVector<int,5UL,columnVector>;
1146 using T2 = DynamicVector<double,columnVector>;
1147 using RT = HybridVector<double,5UL,columnVector>;
1148 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1149
1150 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1151 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1152 }
1153 {
1154 using T1 = HybridVector<int,5UL,rowVector>;
1155 using T2 = DynamicVector<double,rowVector>;
1156 using RT = HybridVector<double,5UL,rowVector>;
1157 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1158
1159 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1160 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1161 }
1162 }
1163
1164 // .../CustomVector
1165 {
1166 {
1167 using T1 = HybridVector<int,5UL,columnVector>;
1168 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1169 using RT = HybridVector<double,5UL,columnVector>;
1170 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1171
1172 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1173 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1174 }
1175 {
1176 using T1 = HybridVector<int,5UL,rowVector>;
1177 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1178 using RT = HybridVector<double,5UL,rowVector>;
1179 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1180
1181 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1182 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1183 }
1184 }
1185
1186 // .../UniformVector
1187 {
1188 {
1189 using T1 = HybridVector<int,5UL,columnVector>;
1190 using T2 = UniformVector<double,columnVector>;
1191 using RT = HybridVector<double,5UL,columnVector>;
1192 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1193
1194 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1195 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1196 }
1197 {
1198 using T1 = HybridVector<int,5UL,rowVector>;
1199 using T2 = UniformVector<double,rowVector>;
1200 using RT = HybridVector<double,5UL,rowVector>;
1201 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1202
1203 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1204 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1205 }
1206 }
1207
1208 // .../InitializerVector
1209 {
1210 {
1211 using T1 = HybridVector<int,5UL,columnVector>;
1212 using T2 = InitializerVector<double,columnVector>;
1213 using RT = HybridVector<double,5UL,columnVector>;
1214 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1215
1216 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1217 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1218 }
1219 {
1220 using T1 = HybridVector<int,5UL,rowVector>;
1221 using T2 = InitializerVector<double,rowVector>;
1222 using RT = HybridVector<double,5UL,rowVector>;
1223 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1224
1225 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1226 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1227 }
1228 }
1229 }
1230
1231 // DynamicVector/...
1232 {
1233 // .../StaticVector
1234 {
1235 {
1236 using T1 = DynamicVector<int,columnVector>;
1237 using T2 = StaticVector<double,3UL,columnVector>;
1238 using RT = StaticVector<double,3UL,columnVector>;
1239 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1240
1241 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1242 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1243 }
1244 {
1245 using T1 = DynamicVector<int,rowVector>;
1246 using T2 = StaticVector<double,3UL,rowVector>;
1247 using RT = StaticVector<double,3UL,rowVector>;
1248 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1249
1250 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1251 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1252 }
1253 }
1254
1255 // .../HybridVector
1256 {
1257 {
1258 using T1 = DynamicVector<int,columnVector>;
1259 using T2 = HybridVector<double,7UL,columnVector>;
1260 using RT = HybridVector<double,7UL,columnVector>;
1261 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1262
1263 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1264 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1265 }
1266 {
1267 using T1 = DynamicVector<int,rowVector>;
1268 using T2 = HybridVector<double,7UL,rowVector>;
1269 using RT = HybridVector<double,7UL,rowVector>;
1270 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1271
1272 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1273 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1274 }
1275 }
1276
1277 // .../DynamicVector
1278 {
1279 {
1280 using T1 = DynamicVector<int,columnVector>;
1281 using T2 = DynamicVector<double,columnVector>;
1282 using RT = DynamicVector<double,columnVector>;
1283 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1284
1285 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1286 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1287 }
1288 {
1289 using T1 = DynamicVector<int,rowVector>;
1290 using T2 = DynamicVector<double,rowVector>;
1291 using RT = DynamicVector<double,rowVector>;
1292 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1293
1294 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1295 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1296 }
1297 }
1298
1299 // .../CustomVector
1300 {
1301 {
1302 using T1 = DynamicVector<int,columnVector>;
1303 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1304 using RT = DynamicVector<double,columnVector>;
1305 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1306
1307 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1308 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1309 }
1310 {
1311 using T1 = DynamicVector<int,rowVector>;
1312 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1313 using RT = DynamicVector<double,rowVector>;
1314 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1315
1316 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1317 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1318 }
1319 }
1320
1321 // .../UniformVector
1322 {
1323 {
1324 using T1 = DynamicVector<int,columnVector>;
1325 using T2 = UniformVector<double,columnVector>;
1326 using RT = DynamicVector<double,columnVector>;
1327 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1328
1329 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1330 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1331 }
1332 {
1333 using T1 = DynamicVector<int,rowVector>;
1334 using T2 = UniformVector<double,rowVector>;
1335 using RT = DynamicVector<double,rowVector>;
1336 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1337
1338 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1339 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1340 }
1341 }
1342
1343 // .../InitializerVector
1344 {
1345 {
1346 using T1 = DynamicVector<int,columnVector>;
1347 using T2 = InitializerVector<double,columnVector>;
1348 using RT = DynamicVector<double,columnVector>;
1349 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1350
1351 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1352 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1353 }
1354 {
1355 using T1 = DynamicVector<int,rowVector>;
1356 using T2 = InitializerVector<double,rowVector>;
1357 using RT = DynamicVector<double,rowVector>;
1358 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1359
1360 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1361 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1362 }
1363 }
1364 }
1365
1366 // CustomVector/...
1367 {
1368 // .../StaticVector
1369 {
1370 {
1371 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
1372 using T2 = StaticVector<double,3UL,columnVector>;
1373 using RT = StaticVector<double,3UL,columnVector>;
1374 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1375
1376 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1377 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1378 }
1379 {
1380 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
1381 using T2 = StaticVector<double,3UL,rowVector>;
1382 using RT = StaticVector<double,3UL,rowVector>;
1383 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1384
1385 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1386 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1387 }
1388 }
1389
1390 // .../HybridVector
1391 {
1392 {
1393 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
1394 using T2 = HybridVector<double,7UL,columnVector>;
1395 using RT = HybridVector<double,7UL,columnVector>;
1396 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1397
1398 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1399 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1400 }
1401 {
1402 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
1403 using T2 = HybridVector<double,7UL,rowVector>;
1404 using RT = HybridVector<double,7UL,rowVector>;
1405 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1406
1407 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1408 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1409 }
1410 }
1411
1412 // .../DynamicVector
1413 {
1414 {
1415 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
1416 using T2 = DynamicVector<double,columnVector>;
1417 using RT = DynamicVector<double,columnVector>;
1418 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1419
1420 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1421 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1422 }
1423 {
1424 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
1425 using T2 = DynamicVector<double,rowVector>;
1426 using RT = DynamicVector<double,rowVector>;
1427 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1428
1429 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1430 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1431 }
1432 }
1433
1434 // .../CustomVector
1435 {
1436 {
1437 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
1438 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1439 using RT = DynamicVector<double,columnVector>;
1440 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1441
1442 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1443 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1444 }
1445 {
1446 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
1447 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1448 using RT = DynamicVector<double,rowVector>;
1449 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1450
1451 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1452 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1453 }
1454 }
1455
1456 // .../UniformVector
1457 {
1458 {
1459 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
1460 using T2 = UniformVector<double,columnVector>;
1461 using RT = DynamicVector<double,columnVector>;
1462 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1463
1464 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1465 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1466 }
1467 {
1468 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
1469 using T2 = UniformVector<double,rowVector>;
1470 using RT = DynamicVector<double,rowVector>;
1471 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1472
1473 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1474 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1475 }
1476 }
1477
1478 // .../InitializerVector
1479 {
1480 {
1481 using T1 = CustomVector<int,unaligned,unpadded,columnVector>;
1482 using T2 = InitializerVector<double,columnVector>;
1483 using RT = DynamicVector<double,columnVector>;
1484 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1485
1486 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1487 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1488 }
1489 {
1490 using T1 = CustomVector<int,unaligned,unpadded,rowVector>;
1491 using T2 = InitializerVector<double,rowVector>;
1492 using RT = DynamicVector<double,rowVector>;
1493 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1494
1495 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1496 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1497 }
1498 }
1499 }
1500
1501 // DynamicVector/...
1502 {
1503 // .../StaticVector
1504 {
1505 {
1506 using T1 = UniformVector<int,columnVector>;
1507 using T2 = StaticVector<double,3UL,columnVector>;
1508 using RT = StaticVector<double,3UL,columnVector>;
1509 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1510
1511 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1512 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1513 }
1514 {
1515 using T1 = UniformVector<int,rowVector>;
1516 using T2 = StaticVector<double,3UL,rowVector>;
1517 using RT = StaticVector<double,3UL,rowVector>;
1518 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1519
1520 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1521 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1522 }
1523 }
1524
1525 // .../HybridVector
1526 {
1527 {
1528 using T1 = UniformVector<int,columnVector>;
1529 using T2 = HybridVector<double,7UL,columnVector>;
1530 using RT = HybridVector<double,7UL,columnVector>;
1531 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1532
1533 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1534 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1535 }
1536 {
1537 using T1 = UniformVector<int,rowVector>;
1538 using T2 = HybridVector<double,7UL,rowVector>;
1539 using RT = HybridVector<double,7UL,rowVector>;
1540 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1541
1542 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1543 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1544 }
1545 }
1546
1547 // .../DynamicVector
1548 {
1549 {
1550 using T1 = UniformVector<int,columnVector>;
1551 using T2 = DynamicVector<double,columnVector>;
1552 using RT = DynamicVector<double,columnVector>;
1553 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1554
1555 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1556 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1557 }
1558 {
1559 using T1 = UniformVector<int,rowVector>;
1560 using T2 = DynamicVector<double,rowVector>;
1561 using RT = DynamicVector<double,rowVector>;
1562 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1563
1564 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1565 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1566 }
1567 }
1568
1569 // .../CustomVector
1570 {
1571 {
1572 using T1 = UniformVector<int,columnVector>;
1573 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1574 using RT = DynamicVector<double,columnVector>;
1575 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1576
1577 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1578 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1579 }
1580 {
1581 using T1 = UniformVector<int,rowVector>;
1582 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1583 using RT = DynamicVector<double,rowVector>;
1584 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1585
1586 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1587 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1588 }
1589 }
1590
1591 // .../UniformVector
1592 {
1593 {
1594 using T1 = UniformVector<int,columnVector>;
1595 using T2 = UniformVector<double,columnVector>;
1596 using RT = UniformVector<double,columnVector>;
1597 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1598
1599 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1600 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1601 }
1602 {
1603 using T1 = UniformVector<int,rowVector>;
1604 using T2 = UniformVector<double,rowVector>;
1605 using RT = UniformVector<double,rowVector>;
1606 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1607
1608 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1609 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1610 }
1611 }
1612
1613 // .../InitializerVector
1614 {
1615 {
1616 using T1 = UniformVector<int,columnVector>;
1617 using T2 = InitializerVector<double,columnVector>;
1618 using RT = DynamicVector<double,columnVector>;
1619 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1620
1621 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1622 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1623 }
1624 {
1625 using T1 = UniformVector<int,rowVector>;
1626 using T2 = InitializerVector<double,rowVector>;
1627 using RT = DynamicVector<double,rowVector>;
1628 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1629
1630 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1631 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1632 }
1633 }
1634 }
1635
1636 // InitializerVector/...
1637 {
1638 // .../StaticVector
1639 {
1640 {
1641 using T1 = InitializerVector<int,columnVector>;
1642 using T2 = StaticVector<double,3UL,columnVector>;
1643 using RT = StaticVector<double,3UL,columnVector>;
1644 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1645
1646 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1647 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1648 }
1649 {
1650 using T1 = InitializerVector<int,rowVector>;
1651 using T2 = StaticVector<double,3UL,rowVector>;
1652 using RT = StaticVector<double,3UL,rowVector>;
1653 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1654
1655 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1656 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1657 }
1658 }
1659
1660 // .../HybridVector
1661 {
1662 {
1663 using T1 = InitializerVector<int,columnVector>;
1664 using T2 = HybridVector<double,7UL,columnVector>;
1665 using RT = HybridVector<double,7UL,columnVector>;
1666 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1667
1668 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1669 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1670 }
1671 {
1672 using T1 = InitializerVector<int,rowVector>;
1673 using T2 = HybridVector<double,7UL,rowVector>;
1674 using RT = HybridVector<double,7UL,rowVector>;
1675 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1676
1677 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1678 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1679 }
1680 }
1681
1682 // .../DynamicVector
1683 {
1684 {
1685 using T1 = InitializerVector<int,columnVector>;
1686 using T2 = DynamicVector<double,columnVector>;
1687 using RT = DynamicVector<double,columnVector>;
1688 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1689
1690 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1691 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1692 }
1693 {
1694 using T1 = InitializerVector<int,rowVector>;
1695 using T2 = DynamicVector<double,rowVector>;
1696 using RT = DynamicVector<double,rowVector>;
1697 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1698
1699 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1700 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1701 }
1702 }
1703
1704 // .../CustomVector
1705 {
1706 {
1707 using T1 = InitializerVector<int,columnVector>;
1708 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1709 using RT = DynamicVector<double,columnVector>;
1710 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1711
1712 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1713 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1714 }
1715 {
1716 using T1 = InitializerVector<int,rowVector>;
1717 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1718 using RT = DynamicVector<double,rowVector>;
1719 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1720
1721 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1722 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1723 }
1724 }
1725
1726 // .../UniformVector
1727 {
1728 {
1729 using T1 = InitializerVector<int,columnVector>;
1730 using T2 = UniformVector<double,columnVector>;
1731 using RT = DynamicVector<double,columnVector>;
1732 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1733
1734 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1735 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1736 }
1737 {
1738 using T1 = InitializerVector<int,rowVector>;
1739 using T2 = UniformVector<double,rowVector>;
1740 using RT = DynamicVector<double,rowVector>;
1741 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1742
1743 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1744 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1745 }
1746 }
1747
1748 // .../InitializerVector
1749 {
1750 {
1751 using T1 = InitializerVector<int,columnVector>;
1752 using T2 = InitializerVector<double,columnVector>;
1753 using RT = DynamicVector<double,columnVector>;
1754 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1755
1756 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1757 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1758 }
1759 {
1760 using T1 = InitializerVector<int,rowVector>;
1761 using T2 = InitializerVector<double,rowVector>;
1762 using RT = DynamicVector<double,rowVector>;
1763 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1764
1765 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1766 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1767 }
1768 }
1769 }
1770
1771 // CompressedVector/...
1772 {
1773 // .../StaticVector
1774 {
1775 {
1776 using T1 = CompressedVector<int,columnVector>;
1777 using T2 = StaticVector<double,3UL,columnVector>;
1778 using RT = CompressedVector<double,columnVector>;
1779 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1780
1781 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1782 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1783 }
1784 {
1785 using T1 = CompressedVector<int,rowVector>;
1786 using T2 = StaticVector<double,3UL,rowVector>;
1787 using RT = CompressedVector<double,rowVector>;
1788 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1789
1790 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1791 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1792 }
1793 }
1794
1795 // .../HybridVector
1796 {
1797 {
1798 using T1 = CompressedVector<int,columnVector>;
1799 using T2 = HybridVector<double,7UL,columnVector>;
1800 using RT = CompressedVector<double,columnVector>;
1801 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1802
1803 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1804 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1805 }
1806 {
1807 using T1 = CompressedVector<int,rowVector>;
1808 using T2 = HybridVector<double,7UL,rowVector>;
1809 using RT = CompressedVector<double,rowVector>;
1810 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1811
1812 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1813 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1814 }
1815 }
1816
1817 // .../DynamicVector
1818 {
1819 {
1820 using T1 = CompressedVector<int,columnVector>;
1821 using T2 = DynamicVector<double,columnVector>;
1822 using RT = CompressedVector<double,columnVector>;
1823 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1824
1825 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1826 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1827 }
1828 {
1829 using T1 = CompressedVector<int,rowVector>;
1830 using T2 = DynamicVector<double,rowVector>;
1831 using RT = CompressedVector<double,rowVector>;
1832 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1833
1834 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1835 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1836 }
1837 }
1838
1839 // .../CustomVector
1840 {
1841 {
1842 using T1 = CompressedVector<int,columnVector>;
1843 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1844 using RT = CompressedVector<double,columnVector>;
1845 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1846
1847 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1848 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1849 }
1850 {
1851 using T1 = CompressedVector<int,rowVector>;
1852 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1853 using RT = CompressedVector<double,rowVector>;
1854 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1855
1856 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1857 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1858 }
1859 }
1860
1861 // .../UniformVector
1862 {
1863 {
1864 using T1 = CompressedVector<int,columnVector>;
1865 using T2 = UniformVector<double,columnVector>;
1866 using RT = CompressedVector<double,columnVector>;
1867 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1868
1869 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1870 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1871 }
1872 {
1873 using T1 = CompressedVector<int,rowVector>;
1874 using T2 = UniformVector<double,rowVector>;
1875 using RT = CompressedVector<double,rowVector>;
1876 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1877
1878 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1879 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1880 }
1881 }
1882
1883 // .../InitializerVector
1884 {
1885 {
1886 using T1 = CompressedVector<int,columnVector>;
1887 using T2 = InitializerVector<double,columnVector>;
1888 using RT = CompressedVector<double,columnVector>;
1889 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1890
1891 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1892 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1893 }
1894 {
1895 using T1 = CompressedVector<int,rowVector>;
1896 using T2 = InitializerVector<double,rowVector>;
1897 using RT = CompressedVector<double,rowVector>;
1898 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1899
1900 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1901 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1902 }
1903 }
1904 }
1905
1906 // ZeroVector/...
1907 {
1908 // .../StaticVector
1909 {
1910 {
1911 using T1 = ZeroVector<int,columnVector>;
1912 using T2 = StaticVector<double,3UL,columnVector>;
1913 using RT = ZeroVector<double,columnVector>;
1914 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1915
1916 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1917 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1918 }
1919 {
1920 using T1 = ZeroVector<int,rowVector>;
1921 using T2 = StaticVector<double,3UL,rowVector>;
1922 using RT = ZeroVector<double,rowVector>;
1923 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1924
1925 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1926 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1927 }
1928 }
1929
1930 // .../HybridVector
1931 {
1932 {
1933 using T1 = ZeroVector<int,columnVector>;
1934 using T2 = HybridVector<double,7UL,columnVector>;
1935 using RT = ZeroVector<double,columnVector>;
1936 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1937
1938 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1939 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1940 }
1941 {
1942 using T1 = ZeroVector<int,rowVector>;
1943 using T2 = HybridVector<double,7UL,rowVector>;
1944 using RT = ZeroVector<double,rowVector>;
1945 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1946
1947 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1948 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1949 }
1950 }
1951
1952 // .../DynamicVector
1953 {
1954 {
1955 using T1 = ZeroVector<int,columnVector>;
1956 using T2 = DynamicVector<double,columnVector>;
1957 using RT = ZeroVector<double,columnVector>;
1958 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1959
1960 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1961 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1962 }
1963 {
1964 using T1 = ZeroVector<int,rowVector>;
1965 using T2 = DynamicVector<double,rowVector>;
1966 using RT = ZeroVector<double,rowVector>;
1967 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1968
1969 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1970 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1971 }
1972 }
1973
1974 // .../CustomVector
1975 {
1976 {
1977 using T1 = ZeroVector<int,columnVector>;
1978 using T2 = CustomVector<double,unaligned,unpadded,columnVector>;
1979 using RT = ZeroVector<double,columnVector>;
1980 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1981
1982 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1983 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1984 }
1985 {
1986 using T1 = ZeroVector<int,rowVector>;
1987 using T2 = CustomVector<double,unaligned,unpadded,rowVector>;
1988 using RT = ZeroVector<double,rowVector>;
1989 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
1990
1991 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
1992 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
1993 }
1994 }
1995
1996 // .../UniformVector
1997 {
1998 {
1999 using T1 = ZeroVector<int,columnVector>;
2000 using T2 = UniformVector<double,columnVector>;
2001 using RT = ZeroVector<double,columnVector>;
2002 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2003
2004 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
2005 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
2006 }
2007 {
2008 using T1 = ZeroVector<int,rowVector>;
2009 using T2 = UniformVector<double,rowVector>;
2010 using RT = ZeroVector<double,rowVector>;
2011 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2012
2013 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
2014 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
2015 }
2016 }
2017
2018 // .../InitializerVector
2019 {
2020 {
2021 using T1 = ZeroVector<int,columnVector>;
2022 using T2 = InitializerVector<double,columnVector>;
2023 using RT = ZeroVector<double,columnVector>;
2024 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2025
2026 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
2027 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
2028 }
2029 {
2030 using T1 = ZeroVector<int,rowVector>;
2031 using T2 = InitializerVector<double,rowVector>;
2032 using RT = ZeroVector<double,rowVector>;
2033 static_assert( IsSame_v< DivTrait_t<T1,T2>, RT >, "Non-matching type detected" );
2034
2035 using Expr = RemoveCVRef_t< decltype( std::declval<T1>() / std::declval<T2>() ) >;
2036 static_assert( TransposeFlag_v<Expr> == TransposeFlag_v<RT>, "Non-matching transpose flag detected" );
2037 }
2038 }
2039 }
2040 }
2041 //*************************************************************************************************
2042
2043 } // namespace divtrait
2044
2045 } // namespace traits
2046
2047 } // namespace mathtest
2048
2049 } // namespace blazetest
2050
2051
2052
2053
2054 //=================================================================================================
2055 //
2056 // MAIN FUNCTION
2057 //
2058 //=================================================================================================
2059
2060 //*************************************************************************************************
main()2061 int main()
2062 {
2063 std::cout << " Running DivTrait class test..." << std::endl;
2064
2065 try
2066 {
2067 RUN_DIVTRAIT_CLASS_TEST;
2068 }
2069 catch( std::exception& ex ) {
2070 std::cerr << "\n\n ERROR DETECTED during DivTrait class test:\n"
2071 << ex.what() << "\n";
2072 return EXIT_FAILURE;
2073 }
2074
2075 return EXIT_SUCCESS;
2076 }
2077 //*************************************************************************************************
2078