1 //=================================================================================================
2 /*!
3 // \file src/mathtest/vectors/customvector/UnalignedPaddedTest.cpp
4 // \brief Source file for the unaligned/padded CustomVector 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 <array>
41 #include <cstdlib>
42 #include <iostream>
43 #include <memory>
44 #include <blaze/math/CompressedVector.h>
45 #include <blaze/math/shims/Equal.h>
46 #include <blaze/util/Complex.h>
47 #include <blaze/util/Memory.h>
48 #include <blaze/util/policies/ArrayDelete.h>
49 #include <blaze/util/policies/Deallocate.h>
50 #include <blaze/util/Random.h>
51 #include <blaze/util/typetraits/IsVectorizable.h>
52 #include <blazetest/mathtest/RandomMaximum.h>
53 #include <blazetest/mathtest/RandomMinimum.h>
54 #include <blazetest/mathtest/vectors/customvector/UnalignedPaddedTest.h>
55
56 #ifdef BLAZE_USE_HPX_THREADS
57 # include <hpx/hpx_main.hpp>
58 #endif
59
60
61 namespace blazetest {
62
63 namespace mathtest {
64
65 namespace vectors {
66
67 namespace customvector {
68
69 //=================================================================================================
70 //
71 // CONSTRUCTORS
72 //
73 //=================================================================================================
74
75 //*************************************************************************************************
76 /*!\brief Constructor for the unaligned/padded CustomVector class test.
77 //
78 // \exception std::runtime_error Operation error detected.
79 */
UnalignedPaddedTest()80 UnalignedPaddedTest::UnalignedPaddedTest()
81 {
82 testConstructors();
83 testAssignment();
84 testAddAssign();
85 testSubAssign();
86 testMultAssign();
87 testDivAssign();
88 testCrossAssign();
89 testScaling();
90 testSubscript();
91 testAt();
92 testIterator();
93 testNonZeros();
94 testReset();
95 testClear();
96 testSwap();
97 testIsDefault();
98 }
99 //*************************************************************************************************
100
101
102
103
104 //=================================================================================================
105 //
106 // TEST FUNCTIONS
107 //
108 //=================================================================================================
109
110 //*************************************************************************************************
111 /*!\brief Test of the CustomVector constructors.
112 //
113 // \return void
114 // \exception std::runtime_error Error detected.
115 //
116 // This function performs a test of all constructors of the CustomVector class template.
117 // In case an error is detected, a \a std::runtime_error exception is thrown.
118 */
testConstructors()119 void UnalignedPaddedTest::testConstructors()
120 {
121 //=====================================================================================
122 // Default constructor
123 //=====================================================================================
124
125 {
126 test_ = "CustomVector default constructor";
127
128 VT vec;
129
130 checkSize ( vec, 0UL );
131 checkNonZeros( vec, 0UL );
132 }
133
134
135 //=====================================================================================
136 // Constructor ( Type*, size_t, size_t )
137 //=====================================================================================
138
139 {
140 test_ = "CustomVector constructor ( Type*, size_t, size_t )";
141
142 // Constructing a custom vector of size 10
143 {
144 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
145 VT vec( memory.get(), 10UL, 16UL );
146
147 checkSize ( vec, 10UL );
148 checkCapacity( vec, 16UL );
149 }
150
151 // Trying to construct a custom vector with invalid array of elements
152 try {
153 VT vec( nullptr, 0UL, 0UL );
154
155 std::ostringstream oss;
156 oss << " Test: " << test_ << "\n"
157 << " Error: Constructing a custom vector with a nullptr succeeded\n";
158 throw std::runtime_error( oss.str() );
159 }
160 catch( std::invalid_argument& ) {}
161
162 // Trying to construct a custom vector with invalid padding
163 if( blaze::IsVectorizable<int>::value )
164 {
165 try {
166 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[3UL] );
167 VT vec( memory.get(), 2UL, 3UL );
168
169 std::ostringstream oss;
170 oss << " Test: " << test_ << "\n"
171 << " Error: Constructing a custom vector with invalid padding succeeded\n"
172 << " Details:\n"
173 << " Result:\n" << vec << "\n";
174 throw std::runtime_error( oss.str() );
175 }
176 catch( std::invalid_argument& ) {}
177 }
178 }
179
180
181 //=====================================================================================
182 // Copy constructor
183 //=====================================================================================
184
185 {
186 test_ = "CustomVector copy constructor (size 0)";
187
188 VT vec1;
189 VT vec2( vec1 );
190
191 checkSize ( vec2, 0UL );
192 checkNonZeros( vec2, 0UL );
193 }
194
195 {
196 test_ = "CustomVector copy constructor (size 5)";
197
198 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
199 VT vec1( memory.get(), 5UL, 16UL );
200 vec1[0] = 1;
201 vec1[1] = 2;
202 vec1[2] = 3;
203 vec1[3] = 4;
204 vec1[4] = 5;
205 VT vec2( vec1 );
206
207 checkSize ( vec2, 5UL );
208 checkCapacity( vec2, 5UL );
209 checkNonZeros( vec2, 5UL );
210
211 if( vec1.data() != vec2.data() ||
212 vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
213 std::ostringstream oss;
214 oss << " Test: " << test_ << "\n"
215 << " Error: Construction failed\n"
216 << " Details:\n"
217 << " Result:\n" << vec2 << "\n"
218 << " Expected result:\n( 1 2 3 4 5 )\n";
219 throw std::runtime_error( oss.str() );
220 }
221 }
222
223
224 //=====================================================================================
225 // Move constructor
226 //=====================================================================================
227
228 {
229 test_ = "CustomVector move constructor (size 0)";
230
231 VT vec1;
232 VT vec2( std::move( vec1 ) );
233
234 checkSize ( vec2, 0UL );
235 checkNonZeros( vec2, 0UL );
236 }
237
238 {
239 test_ = "CustomVector copy constructor (size 5)";
240
241 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
242 VT vec1( memory.get(), 5UL, 16UL );
243 vec1[0] = 1;
244 vec1[1] = 2;
245 vec1[2] = 3;
246 vec1[3] = 4;
247 vec1[4] = 5;
248 VT vec2( std::move( vec1 ) );
249
250 checkSize ( vec2, 5UL );
251 checkCapacity( vec2, 5UL );
252 checkNonZeros( vec2, 5UL );
253
254 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
255 std::ostringstream oss;
256 oss << " Test: " << test_ << "\n"
257 << " Error: Construction failed\n"
258 << " Details:\n"
259 << " Result:\n" << vec2 << "\n"
260 << " Expected result:\n( 1 2 3 4 5 )\n";
261 throw std::runtime_error( oss.str() );
262 }
263 }
264 }
265 //*************************************************************************************************
266
267
268 //*************************************************************************************************
269 /*!\brief Test of the CustomVector assignment operators.
270 //
271 // \return void
272 // \exception std::runtime_error Error detected.
273 //
274 // This function performs a test of all assignment operators of the CustomVector class template.
275 // In case an error is detected, a \a std::runtime_error exception is thrown.
276 */
testAssignment()277 void UnalignedPaddedTest::testAssignment()
278 {
279 //=====================================================================================
280 // Homogeneous assignment
281 //=====================================================================================
282
283 {
284 test_ = "CustomVector homogeneous assignment";
285
286 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
287 VT vec( memory.get(), 3UL, 16UL );
288 vec = 2;
289
290 checkSize ( vec, 3UL );
291 checkCapacity( vec, 3UL );
292 checkNonZeros( vec, 3UL );
293
294 if( vec[0] != 2 || vec[1] != 2 || vec[2] != 2 ) {
295 std::ostringstream oss;
296 oss << " Test: " << test_ << "\n"
297 << " Error: Assignment failed\n"
298 << " Details:\n"
299 << " Result:\n" << vec << "\n"
300 << " Expected result:\n( 2 2 2 )\n";
301 throw std::runtime_error( oss.str() );
302 }
303 }
304
305
306 //=====================================================================================
307 // List assignment
308 //=====================================================================================
309
310 {
311 test_ = "CustomVector initializer list assignment (complete list)";
312
313 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
314 VT vec( memory.get(), 4UL, 16UL );
315 vec = { 1, 2, 3, 4 };
316
317 checkSize ( vec, 4UL );
318 checkCapacity( vec, 4UL );
319 checkNonZeros( vec, 4UL );
320
321 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
322 std::ostringstream oss;
323 oss << " Test: " << test_ << "\n"
324 << " Error: Assignment failed\n"
325 << " Details:\n"
326 << " Result:\n" << vec << "\n"
327 << " Expected result:\n( 1 2 3 4 )\n";
328 throw std::runtime_error( oss.str() );
329 }
330 }
331
332 {
333 test_ = "CustomVector initializer list assignment (incomplete list)";
334
335 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
336 VT vec( memory.get(), 4UL, 16UL );
337 vec = { 1, 2 };
338
339 checkSize ( vec, 4UL );
340 checkCapacity( vec, 4UL );
341 checkNonZeros( vec, 2UL );
342
343 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 0 || vec[3] != 0 ) {
344 std::ostringstream oss;
345 oss << " Test: " << test_ << "\n"
346 << " Error: Assignment failed\n"
347 << " Details:\n"
348 << " Result:\n" << vec << "\n"
349 << " Expected result:\n( 1 2 0 0 )\n";
350 throw std::runtime_error( oss.str() );
351 }
352 }
353
354
355 //=====================================================================================
356 // Array assignment
357 //=====================================================================================
358
359 {
360 test_ = "CustomVector static array assignment";
361
362 const int array[4] = { 1, 2, 3, 4 };
363 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
364 VT vec( memory.get(), 4UL, 16UL );
365 vec = array;
366
367 checkSize ( vec, 4UL );
368 checkCapacity( vec, 4UL );
369 checkNonZeros( vec, 4UL );
370
371 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
372 std::ostringstream oss;
373 oss << " Test: " << test_ << "\n"
374 << " Error: Assignment failed\n"
375 << " Details:\n"
376 << " Result:\n" << vec << "\n"
377 << " Expected result:\n( 1 2 3 4 )\n";
378 throw std::runtime_error( oss.str() );
379 }
380 }
381
382 {
383 test_ = "CustomVector std::array assignment";
384
385 const std::array<int,4UL> array{ 1, 2, 3, 4 };
386 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
387 VT vec( memory.get(), 4UL, 16UL );
388 vec = array;
389
390 checkSize ( vec, 4UL );
391 checkCapacity( vec, 4UL );
392 checkNonZeros( vec, 4UL );
393
394 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
395 std::ostringstream oss;
396 oss << " Test: " << test_ << "\n"
397 << " Error: Assignment failed\n"
398 << " Details:\n"
399 << " Result:\n" << vec << "\n"
400 << " Expected result:\n( 1 2 3 4 )\n";
401 throw std::runtime_error( oss.str() );
402 }
403 }
404
405
406 //=====================================================================================
407 // Copy assignment
408 //=====================================================================================
409
410 {
411 test_ = "CustomVector copy assignment";
412
413 std::unique_ptr<int[],blaze::ArrayDelete> memory1( new int[16UL] );
414 VT vec1( memory1.get(), 5UL, 16UL );
415 vec1[0] = 1;
416 vec1[1] = 2;
417 vec1[2] = 3;
418 vec1[3] = 4;
419 vec1[4] = 5;
420
421 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
422 VT vec2( memory2.get(), 5UL, 16UL );
423 vec2 = vec1;
424
425 checkSize ( vec2, 5UL );
426 checkCapacity( vec2, 5UL );
427 checkNonZeros( vec2, 5UL );
428
429 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
430 std::ostringstream oss;
431 oss << " Test: " << test_ << "\n"
432 << " Error: Assignment failed\n"
433 << " Details:\n"
434 << " Result:\n" << vec2 << "\n"
435 << " Expected result:\n( 1 2 3 4 5 )\n";
436 throw std::runtime_error( oss.str() );
437 }
438 }
439
440
441 //=====================================================================================
442 // Move assignment
443 //=====================================================================================
444
445 {
446 test_ = "CustomVector move assignment";
447
448 std::unique_ptr<int[],blaze::ArrayDelete> memory1( new int[16UL] );
449 VT vec1( memory1.get(), 5UL, 16UL );
450 vec1[0] = 1;
451 vec1[1] = 2;
452 vec1[2] = 3;
453 vec1[3] = 4;
454 vec1[4] = 5;
455
456 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
457 VT vec2( memory2.get(), 5UL, 16UL );
458 vec2 = std::move( vec1 );
459
460 checkSize ( vec2, 5UL );
461 checkCapacity( vec2, 5UL );
462 checkNonZeros( vec2, 5UL );
463
464 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
465 std::ostringstream oss;
466 oss << " Test: " << test_ << "\n"
467 << " Error: Assignment failed\n"
468 << " Details:\n"
469 << " Result:\n" << vec2 << "\n"
470 << " Expected result:\n( 1 2 3 4 5 )\n";
471 throw std::runtime_error( oss.str() );
472 }
473 }
474
475
476 //=====================================================================================
477 // Dense vector assignment
478 //=====================================================================================
479
480 {
481 test_ = "CustomVector dense vector assignment (mixed type)";
482
483 using blaze::unaligned;
484 using blaze::padded;
485 using blaze::rowVector;
486
487 using UnalignedPadded = blaze::CustomVector<short,unaligned,padded,rowVector>;
488 std::unique_ptr<short[],blaze::Deallocate> memory1( blaze::allocate<short>( 32UL ) );
489 UnalignedPadded vec1( memory1.get(), 5UL, 32UL );
490 vec1[0] = 1;
491 vec1[1] = 2;
492 vec1[2] = 3;
493 vec1[3] = 4;
494 vec1[4] = 5;
495
496 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
497 VT vec2( memory2.get(), 5UL, 16UL );
498 vec2 = vec1;
499
500 checkSize ( vec2, 5UL );
501 checkCapacity( vec2, 5UL );
502 checkNonZeros( vec2, 5UL );
503
504 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
505 std::ostringstream oss;
506 oss << " Test: " << test_ << "\n"
507 << " Error: Assignment failed\n"
508 << " Details:\n"
509 << " Result:\n" << vec2 << "\n"
510 << " Expected result:\n( 1 2 3 4 5 )\n";
511 throw std::runtime_error( oss.str() );
512 }
513 }
514
515 {
516 test_ = "CustomVector dense vector assignment (aligned/padded)";
517
518 using blaze::aligned;
519 using blaze::padded;
520 using blaze::rowVector;
521
522 using AlignedPadded = blaze::CustomVector<int,aligned,padded,rowVector>;
523 std::unique_ptr<int[],blaze::Deallocate> memory1( blaze::allocate<int>( 16UL ) );
524 AlignedPadded vec1( memory1.get(), 5UL, 16UL );
525 vec1[0] = 1;
526 vec1[1] = 2;
527 vec1[2] = 3;
528 vec1[3] = 4;
529 vec1[4] = 5;
530
531 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
532 VT vec2( memory2.get(), 5UL, 16UL );
533 vec2 = vec1;
534
535 checkSize ( vec2, 5UL );
536 checkCapacity( vec2, 5UL );
537 checkNonZeros( vec2, 5UL );
538
539 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
540 std::ostringstream oss;
541 oss << " Test: " << test_ << "\n"
542 << " Error: Assignment failed\n"
543 << " Details:\n"
544 << " Result:\n" << vec2 << "\n"
545 << " Expected result:\n( 1 2 3 4 5 )\n";
546 throw std::runtime_error( oss.str() );
547 }
548 }
549
550 {
551 test_ = "CustomVector dense vector assignment (unaligned/unpadded)";
552
553 using blaze::unaligned;
554 using blaze::unpadded;
555 using blaze::rowVector;
556
557 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,rowVector>;
558 std::unique_ptr<int[]> memory1( new int[6UL] );
559 UnalignedUnpadded vec1( memory1.get()+1UL, 5UL );
560 vec1[0] = 1;
561 vec1[1] = 2;
562 vec1[2] = 3;
563 vec1[3] = 4;
564 vec1[4] = 5;
565
566 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
567 VT vec2( memory2.get(), 5UL, 16UL );
568 vec2 = vec1;
569
570 checkSize ( vec2, 5UL );
571 checkCapacity( vec2, 5UL );
572 checkNonZeros( vec2, 5UL );
573
574 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 || vec2[3] != 4 || vec2[4] != 5 ) {
575 std::ostringstream oss;
576 oss << " Test: " << test_ << "\n"
577 << " Error: Assignment failed\n"
578 << " Details:\n"
579 << " Result:\n" << vec2 << "\n"
580 << " Expected result:\n( 1 2 3 4 5 )\n";
581 throw std::runtime_error( oss.str() );
582 }
583 }
584
585
586 //=====================================================================================
587 // Sparse vector assignment
588 //=====================================================================================
589
590 {
591 test_ = "CustomVector sparse vector assignment";
592
593 blaze::CompressedVector<int,blaze::rowVector> vec1( 5UL );
594 vec1[0] = 1;
595 vec1[2] = 2;
596 vec1[3] = 3;
597
598 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
599 VT vec2( memory.get(), 5UL, 16UL );
600 vec2 = vec1;
601
602 checkSize ( vec2, 5UL );
603 checkCapacity( vec2, 5UL );
604 checkNonZeros( vec2, 3UL );
605
606 if( vec2[0] != 1 || vec2[1] != 0 || vec2[2] != 2 || vec2[3] != 3 || vec2[4] != 0 ) {
607 std::ostringstream oss;
608 oss << " Test: " << test_ << "\n"
609 << " Error: Assignment failed\n"
610 << " Details:\n"
611 << " Result:\n" << vec2 << "\n"
612 << " Expected result:\n( 1 0 2 3 0 )\n";
613 throw std::runtime_error( oss.str() );
614 }
615 }
616 }
617 //*************************************************************************************************
618
619
620 //*************************************************************************************************
621 /*!\brief Test of the CustomVector addition assignment operators.
622 //
623 // \return void
624 // \exception std::runtime_error Error detected.
625 //
626 // This function performs a test of the addition assignment operators of the CustomVector class
627 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
628 */
testAddAssign()629 void UnalignedPaddedTest::testAddAssign()
630 {
631 //=====================================================================================
632 // Dense vector addition assignment
633 //=====================================================================================
634
635 {
636 test_ = "CustomVector dense vector addition assignment (mixed type)";
637
638 using blaze::unaligned;
639 using blaze::padded;
640 using blaze::rowVector;
641
642 using UnalignedPadded = blaze::CustomVector<short,unaligned,padded,rowVector>;
643 std::unique_ptr<short[],blaze::Deallocate> memory1( blaze::allocate<short>( 32UL ) );
644 UnalignedPadded vec1( memory1.get(), 5UL, 32UL );
645 vec1[0] = 1;
646 vec1[1] = 0;
647 vec1[2] = -2;
648 vec1[3] = 3;
649 vec1[4] = 0;
650
651 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
652 VT vec2( memory2.get(), 5UL, 16UL );
653 vec2[0] = 0;
654 vec2[1] = 4;
655 vec2[2] = 2;
656 vec2[3] = -6;
657 vec2[4] = 7;
658
659 vec2 += vec1;
660
661 checkSize ( vec2, 5UL );
662 checkCapacity( vec2, 5UL );
663 checkNonZeros( vec2, 4UL );
664
665 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
666 std::ostringstream oss;
667 oss << " Test: " << test_ << "\n"
668 << " Error: Addition assignment failed\n"
669 << " Details:\n"
670 << " Result:\n" << vec2 << "\n"
671 << " Expected result:\n( 1 4 0 -3 7 )\n";
672 throw std::runtime_error( oss.str() );
673 }
674 }
675
676 {
677 test_ = "CustomVector dense vector addition assignment (aligned/padded)";
678
679 using blaze::aligned;
680 using blaze::padded;
681 using blaze::rowVector;
682
683 using AlignedPadded = blaze::CustomVector<int,aligned,padded,rowVector>;
684 std::unique_ptr<int[],blaze::Deallocate> memory1( blaze::allocate<int>( 16UL ) );
685 AlignedPadded vec1( memory1.get(), 5UL, 16UL );
686 vec1[0] = 1;
687 vec1[1] = 0;
688 vec1[2] = -2;
689 vec1[3] = 3;
690 vec1[4] = 0;
691
692 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
693 VT vec2( memory2.get(), 5UL, 16UL );
694 vec2[0] = 0;
695 vec2[1] = 4;
696 vec2[2] = 2;
697 vec2[3] = -6;
698 vec2[4] = 7;
699
700 vec2 += vec1;
701
702 checkSize ( vec2, 5UL );
703 checkCapacity( vec2, 5UL );
704 checkNonZeros( vec2, 4UL );
705
706 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
707 std::ostringstream oss;
708 oss << " Test: " << test_ << "\n"
709 << " Error: Addition assignment failed\n"
710 << " Details:\n"
711 << " Result:\n" << vec2 << "\n"
712 << " Expected result:\n( 1 4 0 -3 7 )\n";
713 throw std::runtime_error( oss.str() );
714 }
715 }
716
717 {
718 test_ = "CustomVector dense vector addition assignment (unaligned/unpadded)";
719
720 using blaze::unaligned;
721 using blaze::unpadded;
722 using blaze::rowVector;
723
724 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,rowVector>;
725 std::unique_ptr<int[]> memory1( new int[6UL] );
726 UnalignedUnpadded vec1( memory1.get()+1UL, 5UL );
727 vec1[0] = 1;
728 vec1[1] = 0;
729 vec1[2] = -2;
730 vec1[3] = 3;
731 vec1[4] = 0;
732
733 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
734 VT vec2( memory2.get(), 5UL, 16UL );
735 vec2[0] = 0;
736 vec2[1] = 4;
737 vec2[2] = 2;
738 vec2[3] = -6;
739 vec2[4] = 7;
740
741 vec2 += vec1;
742
743 checkSize ( vec2, 5UL );
744 checkCapacity( vec2, 5UL );
745 checkNonZeros( vec2, 4UL );
746
747 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
748 std::ostringstream oss;
749 oss << " Test: " << test_ << "\n"
750 << " Error: Addition assignment failed\n"
751 << " Details:\n"
752 << " Result:\n" << vec2 << "\n"
753 << " Expected result:\n( 1 4 0 -3 7 )\n";
754 throw std::runtime_error( oss.str() );
755 }
756 }
757
758
759 //=====================================================================================
760 // Sparse vector addition assignment
761 //=====================================================================================
762
763 {
764 test_ = "CustomVector sparse vector addition assignment";
765
766 blaze::CompressedVector<int,blaze::rowVector> vec1( 5UL, 3UL );
767 vec1[0] = 1;
768 vec1[2] = -2;
769 vec1[3] = 3;
770
771 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
772 VT vec2( memory.get(), 5UL, 16UL );
773 vec2[0] = 0;
774 vec2[1] = 4;
775 vec2[2] = 2;
776 vec2[3] = -6;
777 vec2[4] = 7;
778
779 vec2 += vec1;
780
781 checkSize ( vec2, 5UL );
782 checkCapacity( vec2, 5UL );
783 checkNonZeros( vec2, 4UL );
784
785 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
786 std::ostringstream oss;
787 oss << " Test: " << test_ << "\n"
788 << " Error: Addition assignment failed\n"
789 << " Details:\n"
790 << " Result:\n" << vec2 << "\n"
791 << " Expected result:\n( 1 4 0 -3 7 )\n";
792 throw std::runtime_error( oss.str() );
793 }
794 }
795 }
796 //*************************************************************************************************
797
798
799 //*************************************************************************************************
800 /*!\brief Test of the CustomVector subtraction assignment operators.
801 //
802 // \return void
803 // \exception std::runtime_error Error detected.
804 //
805 // This function performs a test of the subtraction assignment operators of the CustomVector class
806 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
807 */
testSubAssign()808 void UnalignedPaddedTest::testSubAssign()
809 {
810 //=====================================================================================
811 // Dense vector subtraction assignment
812 //=====================================================================================
813
814 {
815 test_ = "CustomVector dense vector subtraction assignment (mixed type)";
816
817 using blaze::unaligned;
818 using blaze::padded;
819 using blaze::rowVector;
820
821 using UnalignedPadded = blaze::CustomVector<short,unaligned,padded,rowVector>;
822 std::unique_ptr<short[],blaze::Deallocate> memory1( blaze::allocate<short>( 32UL ) );
823 UnalignedPadded vec1( memory1.get(), 5UL, 32UL );
824 vec1[0] = -1;
825 vec1[1] = 0;
826 vec1[2] = 2;
827 vec1[3] = -3;
828 vec1[4] = 0;
829
830 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
831 VT vec2( memory2.get(), 5UL, 16UL );
832 vec2[0] = 0;
833 vec2[1] = 4;
834 vec2[2] = 2;
835 vec2[3] = -6;
836 vec2[4] = 7;
837
838 vec2 -= vec1;
839
840 checkSize ( vec2, 5UL );
841 checkCapacity( vec2, 5UL );
842 checkNonZeros( vec2, 4UL );
843
844 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
845 std::ostringstream oss;
846 oss << " Test: " << test_ << "\n"
847 << " Error: Subtraction assignment failed\n"
848 << " Details:\n"
849 << " Result:\n" << vec2 << "\n"
850 << " Expected result:\n( 1 4 0 -3 7 )\n";
851 throw std::runtime_error( oss.str() );
852 }
853 }
854
855 {
856 test_ = "CustomVector dense vector subtraction assignment (aligned/padded)";
857
858 using blaze::aligned;
859 using blaze::padded;
860 using blaze::rowVector;
861
862 using AlignedPadded = blaze::CustomVector<int,aligned,padded,rowVector>;
863 std::unique_ptr<int[],blaze::Deallocate> memory1( blaze::allocate<int>( 16UL ) );
864 AlignedPadded vec1( memory1.get(), 5UL, 16UL );
865 vec1[0] = -1;
866 vec1[1] = 0;
867 vec1[2] = 2;
868 vec1[3] = -3;
869 vec1[4] = 0;
870
871 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
872 VT vec2( memory2.get(), 5UL, 16UL );
873 vec2[0] = 0;
874 vec2[1] = 4;
875 vec2[2] = 2;
876 vec2[3] = -6;
877 vec2[4] = 7;
878
879 vec2 -= vec1;
880
881 checkSize ( vec2, 5UL );
882 checkCapacity( vec2, 5UL );
883 checkNonZeros( vec2, 4UL );
884
885 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
886 std::ostringstream oss;
887 oss << " Test: " << test_ << "\n"
888 << " Error: Subtraction assignment failed\n"
889 << " Details:\n"
890 << " Result:\n" << vec2 << "\n"
891 << " Expected result:\n( 1 4 0 -3 7 )\n";
892 throw std::runtime_error( oss.str() );
893 }
894 }
895
896 {
897 test_ = "CustomVector dense vector subtraction assignment (unaligned/unpadded)";
898
899 using blaze::unaligned;
900 using blaze::unpadded;
901 using blaze::rowVector;
902
903 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,rowVector>;
904 std::unique_ptr<int[]> memory1( new int[6UL] );
905 UnalignedUnpadded vec1( memory1.get()+1UL, 5UL );
906 vec1[0] = -1;
907 vec1[1] = 0;
908 vec1[2] = 2;
909 vec1[3] = -3;
910 vec1[4] = 0;
911
912 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
913 VT vec2( memory2.get(), 5UL, 16UL );
914 vec2[0] = 0;
915 vec2[1] = 4;
916 vec2[2] = 2;
917 vec2[3] = -6;
918 vec2[4] = 7;
919
920 vec2 -= vec1;
921
922 checkSize ( vec2, 5UL );
923 checkCapacity( vec2, 5UL );
924 checkNonZeros( vec2, 4UL );
925
926 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
927 std::ostringstream oss;
928 oss << " Test: " << test_ << "\n"
929 << " Error: Subtraction assignment failed\n"
930 << " Details:\n"
931 << " Result:\n" << vec2 << "\n"
932 << " Expected result:\n( 1 4 0 -3 7 )\n";
933 throw std::runtime_error( oss.str() );
934 }
935 }
936
937
938 //=====================================================================================
939 // Sparse vector subtraction assignment
940 //=====================================================================================
941
942 {
943 test_ = "CustomVector sparse vector subtraction assignment";
944
945 blaze::CompressedVector<int,blaze::rowVector> vec1( 5UL, 3UL );
946 vec1[0] = -1;
947 vec1[2] = 2;
948 vec1[3] = -3;
949
950 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
951 VT vec2( memory.get(), 5UL, 16UL );
952 vec2[0] = 0;
953 vec2[1] = 4;
954 vec2[2] = 2;
955 vec2[3] = -6;
956 vec2[4] = 7;
957
958 vec2 -= vec1;
959
960 checkSize ( vec2, 5UL );
961 checkCapacity( vec2, 5UL );
962 checkNonZeros( vec2, 4UL );
963
964 if( vec2[0] != 1 || vec2[1] != 4 || vec2[2] != 0 || vec2[3] != -3 || vec2[4] != 7 ) {
965 std::ostringstream oss;
966 oss << " Test: " << test_ << "\n"
967 << " Error: Subtraction assignment failed\n"
968 << " Details:\n"
969 << " Result:\n" << vec2 << "\n"
970 << " Expected result:\n( 1 4 0 -3 7 )\n";
971 throw std::runtime_error( oss.str() );
972 }
973 }
974 }
975 //*************************************************************************************************
976
977
978 //*************************************************************************************************
979 /*!\brief Test of the CustomVector multiplication assignment operators.
980 //
981 // \return void
982 // \exception std::runtime_error Error detected.
983 //
984 // This function performs a test of the multiplication assignment operators of the CustomVector
985 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
986 */
testMultAssign()987 void UnalignedPaddedTest::testMultAssign()
988 {
989 //=====================================================================================
990 // Dense vector multiplication assignment
991 //=====================================================================================
992
993 {
994 test_ = "CustomVector dense vector multiplication assignment (unaligned/padded)";
995
996 using blaze::unaligned;
997 using blaze::padded;
998 using blaze::rowVector;
999
1000 using UnalignedPadded = blaze::CustomVector<short,unaligned,padded,rowVector>;
1001 std::unique_ptr<short[],blaze::Deallocate> memory1( blaze::allocate<short>( 32UL ) );
1002 UnalignedPadded vec1( memory1.get(), 5UL, 32UL );
1003 vec1[0] = 1;
1004 vec1[1] = 0;
1005 vec1[2] = -2;
1006 vec1[3] = 3;
1007 vec1[4] = 0;
1008
1009 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1010 VT vec2( memory2.get(), 5UL, 16UL );
1011 vec2[0] = 0;
1012 vec2[1] = 4;
1013 vec2[2] = 2;
1014 vec2[3] = -6;
1015 vec2[4] = 7;
1016
1017 vec2 *= vec1;
1018
1019 checkSize ( vec2, 5UL );
1020 checkCapacity( vec2, 5UL );
1021 checkNonZeros( vec2, 2UL );
1022
1023 if( vec2[0] != 0 || vec2[1] != 0 || vec2[2] != -4 || vec2[3] != -18 || vec2[4] != 0 ) {
1024 std::ostringstream oss;
1025 oss << " Test: " << test_ << "\n"
1026 << " Error: Multiplication assignment failed\n"
1027 << " Details:\n"
1028 << " Result:\n" << vec2 << "\n"
1029 << " Expected result:\n( 0 0 -4 -18 0 )\n";
1030 throw std::runtime_error( oss.str() );
1031 }
1032 }
1033
1034 {
1035 test_ = "CustomVector dense vector multiplication assignment (aligned/padded)";
1036
1037 using blaze::aligned;
1038 using blaze::padded;
1039 using blaze::rowVector;
1040
1041 using AlignedPadded = blaze::CustomVector<int,aligned,padded,rowVector>;
1042 std::unique_ptr<int[],blaze::Deallocate> memory1( blaze::allocate<int>( 16UL ) );
1043 AlignedPadded vec1( memory1.get(), 5UL, 16UL );
1044 vec1[0] = 1;
1045 vec1[1] = 0;
1046 vec1[2] = -2;
1047 vec1[3] = 3;
1048 vec1[4] = 0;
1049
1050 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1051 VT vec2( memory2.get(), 5UL, 16UL );
1052 vec2[0] = 0;
1053 vec2[1] = 4;
1054 vec2[2] = 2;
1055 vec2[3] = -6;
1056 vec2[4] = 7;
1057
1058 vec2 *= vec1;
1059
1060 checkSize ( vec2, 5UL );
1061 checkCapacity( vec2, 5UL );
1062 checkNonZeros( vec2, 2UL );
1063
1064 if( vec2[0] != 0 || vec2[1] != 0 || vec2[2] != -4 || vec2[3] != -18 || vec2[4] != 0 ) {
1065 std::ostringstream oss;
1066 oss << " Test: " << test_ << "\n"
1067 << " Error: Multiplication assignment failed\n"
1068 << " Details:\n"
1069 << " Result:\n" << vec2 << "\n"
1070 << " Expected result:\n( 0 0 -4 -18 0 )\n";
1071 throw std::runtime_error( oss.str() );
1072 }
1073 }
1074
1075 {
1076 test_ = "CustomVector dense vector multiplication assignment (unaligned/unpadded)";
1077
1078 using blaze::unaligned;
1079 using blaze::unpadded;
1080 using blaze::rowVector;
1081
1082 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,rowVector>;
1083 std::unique_ptr<int[]> memory1( new int[6UL] );
1084 UnalignedUnpadded vec1( memory1.get()+1UL, 5UL );
1085 vec1[0] = 1;
1086 vec1[1] = 0;
1087 vec1[2] = -2;
1088 vec1[3] = 3;
1089 vec1[4] = 0;
1090
1091 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1092 VT vec2( memory2.get(), 5UL, 16UL );
1093 vec2[0] = 0;
1094 vec2[1] = 4;
1095 vec2[2] = 2;
1096 vec2[3] = -6;
1097 vec2[4] = 7;
1098
1099 vec2 *= vec1;
1100
1101 checkSize ( vec2, 5UL );
1102 checkCapacity( vec2, 5UL );
1103 checkNonZeros( vec2, 2UL );
1104
1105 if( vec2[0] != 0 || vec2[1] != 0 || vec2[2] != -4 || vec2[3] != -18 || vec2[4] != 0 ) {
1106 std::ostringstream oss;
1107 oss << " Test: " << test_ << "\n"
1108 << " Error: Multiplication assignment failed\n"
1109 << " Details:\n"
1110 << " Result:\n" << vec2 << "\n"
1111 << " Expected result:\n( 0 0 -4 -18 0 )\n";
1112 throw std::runtime_error( oss.str() );
1113 }
1114 }
1115
1116
1117 //=====================================================================================
1118 // Sparse vector multiplication assignment
1119 //=====================================================================================
1120
1121 {
1122 test_ = "CustomVector sparse vector multiplication assignment";
1123
1124 blaze::CompressedVector<int,blaze::rowVector> vec1( 5UL, 3UL );
1125 vec1[0] = 1;
1126 vec1[2] = -2;
1127 vec1[3] = 3;
1128
1129 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1130 VT vec2( memory.get(), 5UL, 16UL );
1131 vec2[0] = 0;
1132 vec2[1] = 4;
1133 vec2[2] = 2;
1134 vec2[3] = -6;
1135 vec2[4] = 7;
1136
1137 vec2 *= vec1;
1138
1139 checkSize ( vec2, 5UL );
1140 checkCapacity( vec2, 5UL );
1141 checkNonZeros( vec2, 2UL );
1142
1143 if( vec2[0] != 0 || vec2[1] != 0 || vec2[2] != -4 || vec2[3] != -18 || vec2[4] != 0 ) {
1144 std::ostringstream oss;
1145 oss << " Test: " << test_ << "\n"
1146 << " Error: Multiplication assignment failed\n"
1147 << " Details:\n"
1148 << " Result:\n" << vec2 << "\n"
1149 << " Expected result:\n( 0 0 -4 -18 0 )\n";
1150 throw std::runtime_error( oss.str() );
1151 }
1152 }
1153 }
1154 //*************************************************************************************************
1155
1156
1157 //*************************************************************************************************
1158 /*!\brief Test of the CustomVector division assignment operators.
1159 //
1160 // \return void
1161 // \exception std::runtime_error Error detected.
1162 //
1163 // This function performs a test of the division assignment operators of the CustomVector
1164 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1165 */
testDivAssign()1166 void UnalignedPaddedTest::testDivAssign()
1167 {
1168 //=====================================================================================
1169 // Dense vector division assignment
1170 //=====================================================================================
1171
1172 {
1173 test_ = "CustomVector dense vector division assignment (mixed type)";
1174
1175 using blaze::unaligned;
1176 using blaze::padded;
1177 using blaze::rowVector;
1178
1179 using UnalignedPadded = blaze::CustomVector<short,unaligned,padded,rowVector>;
1180 std::unique_ptr<short[],blaze::Deallocate> memory1( blaze::allocate<short>( 32UL ) );
1181 UnalignedPadded vec1( memory1.get(), 5UL, 32UL );
1182 vec1[0] = 1;
1183 vec1[1] = 2;
1184 vec1[2] = -3;
1185 vec1[3] = 4;
1186 vec1[4] = 1;
1187
1188 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1189 VT vec2( memory2.get(), 5UL, 16UL );
1190 vec2[0] = 2;
1191 vec2[1] = 0;
1192 vec2[2] = -3;
1193 vec2[3] = 8;
1194 vec2[4] = 0;
1195
1196 vec2 /= vec1;
1197
1198 checkSize ( vec2, 5UL );
1199 checkCapacity( vec2, 5UL );
1200 checkNonZeros( vec2, 3UL );
1201
1202 if( vec2[0] != 2 || vec2[1] != 0 || vec2[2] != 1 || vec2[3] != 2 || vec2[4] != 0 ) {
1203 std::ostringstream oss;
1204 oss << " Test: " << test_ << "\n"
1205 << " Error: Division assignment failed\n"
1206 << " Details:\n"
1207 << " Result:\n" << vec2 << "\n"
1208 << " Expected result:\n( 2 0 1 2 0 )\n";
1209 throw std::runtime_error( oss.str() );
1210 }
1211 }
1212
1213 {
1214 test_ = "CustomVector dense vector division assignment (aligned/padded)";
1215
1216 using blaze::aligned;
1217 using blaze::padded;
1218 using blaze::rowVector;
1219
1220 using AlignedPadded = blaze::CustomVector<int,aligned,padded,rowVector>;
1221 std::unique_ptr<int[],blaze::Deallocate> memory1( blaze::allocate<int>( 16UL ) );
1222 AlignedPadded vec1( memory1.get(), 5UL, 16UL );
1223 vec1[0] = 1;
1224 vec1[1] = 2;
1225 vec1[2] = -3;
1226 vec1[3] = 4;
1227 vec1[4] = 1;
1228
1229 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1230 VT vec2( memory2.get(), 5UL, 16UL );
1231 vec2[0] = 2;
1232 vec2[1] = 0;
1233 vec2[2] = -3;
1234 vec2[3] = 8;
1235 vec2[4] = 0;
1236
1237 vec2 /= vec1;
1238
1239 checkSize ( vec2, 5UL );
1240 checkCapacity( vec2, 5UL );
1241 checkNonZeros( vec2, 3UL );
1242
1243 if( vec2[0] != 2 || vec2[1] != 0 || vec2[2] != 1 || vec2[3] != 2 || vec2[4] != 0 ) {
1244 std::ostringstream oss;
1245 oss << " Test: " << test_ << "\n"
1246 << " Error: Division assignment failed\n"
1247 << " Details:\n"
1248 << " Result:\n" << vec2 << "\n"
1249 << " Expected result:\n( 2 0 1 2 0 )\n";
1250 throw std::runtime_error( oss.str() );
1251 }
1252 }
1253
1254 {
1255 test_ = "CustomVector dense vector division assignment (unaligned/unpadded)";
1256
1257 using blaze::unaligned;
1258 using blaze::unpadded;
1259 using blaze::rowVector;
1260
1261 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,rowVector>;
1262 std::unique_ptr<int[]> memory1( new int[6UL] );
1263 UnalignedUnpadded vec1( memory1.get()+1UL, 5UL );
1264 vec1[0] = 1;
1265 vec1[1] = 2;
1266 vec1[2] = -3;
1267 vec1[3] = 4;
1268 vec1[4] = 1;
1269
1270 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1271 VT vec2( memory2.get(), 5UL, 16UL );
1272 vec2[0] = 2;
1273 vec2[1] = 0;
1274 vec2[2] = -3;
1275 vec2[3] = 8;
1276 vec2[4] = 0;
1277
1278 vec2 /= vec1;
1279
1280 checkSize ( vec2, 5UL );
1281 checkCapacity( vec2, 5UL );
1282 checkNonZeros( vec2, 3UL );
1283
1284 if( vec2[0] != 2 || vec2[1] != 0 || vec2[2] != 1 || vec2[3] != 2 || vec2[4] != 0 ) {
1285 std::ostringstream oss;
1286 oss << " Test: " << test_ << "\n"
1287 << " Error: Division assignment failed\n"
1288 << " Details:\n"
1289 << " Result:\n" << vec2 << "\n"
1290 << " Expected result:\n( 2 0 1 2 0 )\n";
1291 throw std::runtime_error( oss.str() );
1292 }
1293 }
1294 }
1295 //*************************************************************************************************
1296
1297
1298 //*************************************************************************************************
1299 /*!\brief Test of the CustomVector cross product assignment operators.
1300 //
1301 // \return void
1302 // \exception std::runtime_error Error detected.
1303 //
1304 // This function performs a test of the cross product assignment operators of the CustomVector
1305 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1306 */
testCrossAssign()1307 void UnalignedPaddedTest::testCrossAssign()
1308 {
1309 //=====================================================================================
1310 // Dense vector cross product assignment
1311 //=====================================================================================
1312
1313 {
1314 test_ = "CustomVector dense vector cross product assignment (unaligned/padded)";
1315
1316 using blaze::unaligned;
1317 using blaze::padded;
1318 using blaze::rowVector;
1319
1320 using UnalignedPadded = blaze::CustomVector<short,unaligned,padded,rowVector>;
1321 std::unique_ptr<short[],blaze::Deallocate> memory1( blaze::allocate<short>( 32UL ) );
1322 UnalignedPadded vec1( memory1.get(), 3UL, 32UL );
1323 vec1[0] = 1;
1324 vec1[1] = 0;
1325 vec1[2] = -2;
1326
1327 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1328 VT vec2( memory2.get(), 3UL, 16UL );
1329 vec2[0] = 2;
1330 vec2[1] = 0;
1331 vec2[2] = -1;
1332
1333 vec2 %= vec1;
1334
1335 checkSize ( vec2, 3UL );
1336 checkCapacity( vec2, 3UL );
1337 checkNonZeros( vec2, 1UL );
1338
1339 if( vec2[0] != 0 || vec2[1] != 3 || vec2[2] != 0 ) {
1340 std::ostringstream oss;
1341 oss << " Test: " << test_ << "\n"
1342 << " Error: Cross product assignment failed\n"
1343 << " Details:\n"
1344 << " Result:\n" << vec2 << "\n"
1345 << " Expected result:\n( 0 3 0 )\n";
1346 throw std::runtime_error( oss.str() );
1347 }
1348 }
1349
1350 {
1351 test_ = "CustomVector dense vector cross product assignment (aligned/padded)";
1352
1353 using blaze::aligned;
1354 using blaze::padded;
1355 using blaze::rowVector;
1356
1357 using AlignedPadded = blaze::CustomVector<int,aligned,padded,rowVector>;
1358 std::unique_ptr<int[],blaze::Deallocate> memory1( blaze::allocate<int>( 16UL ) );
1359 AlignedPadded vec1( memory1.get(), 3UL, 16UL );
1360 vec1[0] = 1;
1361 vec1[1] = 0;
1362 vec1[2] = -2;
1363
1364 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1365 VT vec2( memory2.get(), 3UL, 16UL );
1366 vec2[0] = 2;
1367 vec2[1] = 0;
1368 vec2[2] = -1;
1369
1370 vec2 %= vec1;
1371
1372 checkSize ( vec2, 3UL );
1373 checkCapacity( vec2, 3UL );
1374 checkNonZeros( vec2, 1UL );
1375
1376 if( vec2[0] != 0 || vec2[1] != 3 || vec2[2] != 0 ) {
1377 std::ostringstream oss;
1378 oss << " Test: " << test_ << "\n"
1379 << " Error: Cross product assignment failed\n"
1380 << " Details:\n"
1381 << " Result:\n" << vec2 << "\n"
1382 << " Expected result:\n( 0 3 0 )\n";
1383 throw std::runtime_error( oss.str() );
1384 }
1385 }
1386
1387 {
1388 test_ = "CustomVector dense vector cross product assignment (unaligned/unpadded)";
1389
1390 using blaze::unaligned;
1391 using blaze::unpadded;
1392 using blaze::rowVector;
1393
1394 using UnalignedUnpadded = blaze::CustomVector<int,unaligned,unpadded,rowVector>;
1395 std::unique_ptr<int[]> memory1( new int[4UL] );
1396 UnalignedUnpadded vec1( memory1.get()+1UL, 3UL );
1397 vec1[0] = 1;
1398 vec1[1] = 0;
1399 vec1[2] = -2;
1400
1401 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
1402 VT vec2( memory2.get(), 3UL, 16UL );
1403 vec2[0] = 2;
1404 vec2[1] = 0;
1405 vec2[2] = -1;
1406
1407 vec2 %= vec1;
1408
1409 checkSize ( vec2, 3UL );
1410 checkCapacity( vec2, 3UL );
1411 checkNonZeros( vec2, 1UL );
1412
1413 if( vec2[0] != 0 || vec2[1] != 3 || vec2[2] != 0 ) {
1414 std::ostringstream oss;
1415 oss << " Test: " << test_ << "\n"
1416 << " Error: Cross product assignment failed\n"
1417 << " Details:\n"
1418 << " Result:\n" << vec2 << "\n"
1419 << " Expected result:\n( 0 3 0 )\n";
1420 throw std::runtime_error( oss.str() );
1421 }
1422 }
1423
1424
1425 //=====================================================================================
1426 // Sparse vector cross product assignment
1427 //=====================================================================================
1428
1429 {
1430 test_ = "CustomVector sparse vector cross product assignment";
1431
1432 blaze::CompressedVector<int,blaze::rowVector> vec1( 3UL, 2UL );
1433 vec1[0] = 1;
1434 vec1[2] = -2;
1435
1436 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1437 VT vec2( memory.get(), 3UL, 16UL );
1438 vec2[0] = 2;
1439 vec2[1] = 0;
1440 vec2[2] = -1;
1441
1442 vec2 %= vec1;
1443
1444 checkSize ( vec2, 3UL );
1445 checkCapacity( vec2, 3UL );
1446 checkNonZeros( vec2, 1UL );
1447
1448 if( vec2[0] != 0 || vec2[1] != 3 || vec2[2] != 0 ) {
1449 std::ostringstream oss;
1450 oss << " Test: " << test_ << "\n"
1451 << " Error: Cross product assignment failed\n"
1452 << " Details:\n"
1453 << " Result:\n" << vec2 << "\n"
1454 << " Expected result:\n( 0 3 0 )\n";
1455 throw std::runtime_error( oss.str() );
1456 }
1457 }
1458 }
1459 //*************************************************************************************************
1460
1461
1462 //*************************************************************************************************
1463 /*!\brief Test of all CustomVector (self-)scaling operations.
1464 //
1465 // \return void
1466 // \exception std::runtime_error Error detected.
1467 //
1468 // This function performs a test of all available ways to scale an instance of the CustomVector
1469 // class template. In case an error is detected, a \a std::runtime_error exception is thrown.
1470 */
testScaling()1471 void UnalignedPaddedTest::testScaling()
1472 {
1473 //=====================================================================================
1474 // Self-scaling (v*=s)
1475 //=====================================================================================
1476
1477 {
1478 test_ = "CustomVector self-scaling (v*=s)";
1479
1480 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1481 VT vec( memory.get(), 5UL, 16UL );
1482 vec[0] = 1;
1483 vec[1] = 0;
1484 vec[2] = -2;
1485 vec[3] = 3;
1486 vec[4] = 0;
1487
1488 vec *= 2;
1489
1490 checkSize ( vec, 5UL );
1491 checkCapacity( vec, 5UL );
1492 checkNonZeros( vec, 3UL );
1493
1494 if( vec[0] != 2 || vec[1] != 0 || vec[2] != -4 || vec[3] != 6 || vec[4] != 0 ) {
1495 std::ostringstream oss;
1496 oss << " Test: " << test_ << "\n"
1497 << " Error: Failed self-scaling operation\n"
1498 << " Details:\n"
1499 << " Result:\n" << vec << "\n"
1500 << " Expected result:\n( 2 0 -4 6 0 )\n";
1501 throw std::runtime_error( oss.str() );
1502 }
1503 }
1504
1505
1506 //=====================================================================================
1507 // Self-scaling (v=v*s)
1508 //=====================================================================================
1509
1510 {
1511 test_ = "CustomVector self-scaling (v=v*s)";
1512
1513 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1514 VT vec( memory.get(), 5UL, 16UL );
1515 vec[0] = 1;
1516 vec[1] = 0;
1517 vec[2] = -2;
1518 vec[3] = 3;
1519 vec[4] = 0;
1520
1521 vec = vec * 2;
1522
1523 checkSize ( vec, 5UL );
1524 checkCapacity( vec, 5UL );
1525 checkNonZeros( vec, 3UL );
1526
1527 if( vec[0] != 2 || vec[1] != 0 || vec[2] != -4 || vec[3] != 6 || vec[4] != 0 ) {
1528 std::ostringstream oss;
1529 oss << " Test: " << test_ << "\n"
1530 << " Error: Failed self-scaling operation\n"
1531 << " Details:\n"
1532 << " Result:\n" << vec << "\n"
1533 << " Expected result:\n( 2 0 -4 6 0 )\n";
1534 throw std::runtime_error( oss.str() );
1535 }
1536 }
1537
1538
1539 //=====================================================================================
1540 // Self-scaling (v=s*v)
1541 //=====================================================================================
1542
1543 {
1544 test_ = "CustomVector self-scaling (v=s*v)";
1545
1546 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1547 VT vec( memory.get(), 5UL, 16UL );
1548 vec[0] = 1;
1549 vec[1] = 0;
1550 vec[2] = -2;
1551 vec[3] = 3;
1552 vec[4] = 0;
1553
1554 vec = 2 * vec;
1555
1556 checkSize ( vec, 5UL );
1557 checkCapacity( vec, 5UL );
1558 checkNonZeros( vec, 3UL );
1559
1560 if( vec[0] != 2 || vec[1] != 0 || vec[2] != -4 || vec[3] != 6 || vec[4] != 0 ) {
1561 std::ostringstream oss;
1562 oss << " Test: " << test_ << "\n"
1563 << " Error: Failed self-scaling operation\n"
1564 << " Details:\n"
1565 << " Result:\n" << vec << "\n"
1566 << " Expected result:\n( 2 0 -4 6 0 )\n";
1567 throw std::runtime_error( oss.str() );
1568 }
1569 }
1570
1571
1572 //=====================================================================================
1573 // Self-scaling (v/=s)
1574 //=====================================================================================
1575
1576 {
1577 test_ = "CustomVector self-scaling (v/=s)";
1578
1579 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1580 VT vec( memory.get(), 5UL, 16UL );
1581 vec[0] = 2;
1582 vec[1] = 0;
1583 vec[2] = -4;
1584 vec[3] = 6;
1585 vec[4] = 0;
1586
1587 vec /= 2;
1588
1589 checkSize ( vec, 5UL );
1590 checkCapacity( vec, 5UL );
1591 checkNonZeros( vec, 3UL );
1592
1593 if( vec[0] != 1 || vec[1] != 0 || vec[2] != -2 || vec[3] != 3 || vec[4] != 0 ) {
1594 std::ostringstream oss;
1595 oss << " Test: " << test_ << "\n"
1596 << " Error: Failed self-scaling operation\n"
1597 << " Details:\n"
1598 << " Result:\n" << vec << "\n"
1599 << " Expected result:\n( 1 0 -2 3 0 )\n";
1600 throw std::runtime_error( oss.str() );
1601 }
1602 }
1603
1604
1605 //=====================================================================================
1606 // Self-scaling (v=v/s)
1607 //=====================================================================================
1608
1609 {
1610 test_ = "CustomVector self-scaling (v=v/s)";
1611
1612 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1613 VT vec( memory.get(), 5UL, 16UL );
1614 vec[0] = 2;
1615 vec[1] = 0;
1616 vec[2] = -4;
1617 vec[3] = 6;
1618 vec[4] = 0;
1619
1620 vec = vec / 2;
1621
1622 checkSize ( vec, 5UL );
1623 checkCapacity( vec, 5UL );
1624 checkNonZeros( vec, 3UL );
1625
1626 if( vec[0] != 1 || vec[1] != 0 || vec[2] != -2 || vec[3] != 3 || vec[4] != 0 ) {
1627 std::ostringstream oss;
1628 oss << " Test: " << test_ << "\n"
1629 << " Error: Failed self-scaling operation\n"
1630 << " Details:\n"
1631 << " Result:\n" << vec << "\n"
1632 << " Expected result:\n( 1 0 -2 3 0 )\n";
1633 throw std::runtime_error( oss.str() );
1634 }
1635 }
1636
1637
1638 //=====================================================================================
1639 // CustomVector::scale()
1640 //=====================================================================================
1641
1642 {
1643 test_ = "CustomVector::scale() (int)";
1644
1645 // Initialization check
1646 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1647 VT vec( memory.get(), 4UL, 16UL );
1648 vec[0] = 1;
1649 vec[1] = 2;
1650 vec[2] = 3;
1651 vec[3] = 4;
1652
1653 checkSize ( vec, 4UL );
1654 checkCapacity( vec, 4UL );
1655 checkNonZeros( vec, 4UL );
1656
1657 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
1658 std::ostringstream oss;
1659 oss << " Test: " << test_ << "\n"
1660 << " Error: Initialization failed\n"
1661 << " Details:\n"
1662 << " Result:\n" << vec << "\n"
1663 << " Expected result:\n( 1 2 3 4 )\n";
1664 throw std::runtime_error( oss.str() );
1665 }
1666
1667 // Integral scaling of the vector
1668 vec.scale( 2 );
1669
1670 checkSize ( vec, 4UL );
1671 checkCapacity( vec, 4UL );
1672 checkNonZeros( vec, 4UL );
1673
1674 if( vec[0] != 2 || vec[1] != 4 || vec[2] != 6 || vec[3] != 8 ) {
1675 std::ostringstream oss;
1676 oss << " Test: " << test_ << "\n"
1677 << " Error: Scale operation failed\n"
1678 << " Details:\n"
1679 << " Result:\n" << vec << "\n"
1680 << " Expected result:\n( 2 4 6 8 )\n";
1681 throw std::runtime_error( oss.str() );
1682 }
1683
1684 // Floating point scaling of the vector
1685 vec.scale( 0.5 );
1686
1687 checkSize ( vec, 4UL );
1688 checkCapacity( vec, 4UL );
1689 checkNonZeros( vec, 4UL );
1690
1691 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
1692 std::ostringstream oss;
1693 oss << " Test: " << test_ << "\n"
1694 << " Error: Scale operation failed\n"
1695 << " Details:\n"
1696 << " Result:\n" << vec << "\n"
1697 << " Expected result:\n( 1 2 3 4 )\n";
1698 throw std::runtime_error( oss.str() );
1699 }
1700 }
1701
1702 {
1703 test_ = "CustomVector::scale() (complex)";
1704
1705 using blaze::complex;
1706 using blaze::unaligned;
1707 using blaze::padded;
1708 using blaze::rowVector;
1709
1710 using cplx = complex<float>;
1711 using UnalignedPadded = blaze::CustomVector<cplx,unaligned,padded,rowVector>;
1712 std::unique_ptr<cplx[],blaze::ArrayDelete> memory( new cplx[8UL] );
1713 UnalignedPadded vec( memory.get(), 2UL, 8UL );
1714 vec[0] = cplx( 1.0F, 0.0F );
1715 vec[1] = cplx( 2.0F, 0.0F );
1716 vec.scale( cplx( 3.0F, 0.0F ) );
1717
1718 checkSize ( vec, 2UL );
1719 checkCapacity( vec, 2UL );
1720 checkNonZeros( vec, 2UL );
1721
1722 if( vec[0] != cplx( 3.0F, 0.0F ) || vec[1] != cplx( 6.0F, 0.0F ) ) {
1723 std::ostringstream oss;
1724 oss << " Test: " << test_ << "\n"
1725 << " Error: Scale operation failed\n"
1726 << " Details:\n"
1727 << " Result:\n" << vec << "\n"
1728 << " Expected result:\n( (3,0) (6,0) )\n";
1729 throw std::runtime_error( oss.str() );
1730 }
1731 }
1732 }
1733 //*************************************************************************************************
1734
1735
1736 //*************************************************************************************************
1737 /*!\brief Test of the CustomVector subscript operator.
1738 //
1739 // \return void
1740 // \exception std::runtime_error Error detected.
1741 //
1742 // This function performs a test of adding and accessing elements via the subscript operator
1743 // of the CustomVector class template. In case an error is detected, a \a std::runtime_error
1744 // exception is thrown.
1745 */
testSubscript()1746 void UnalignedPaddedTest::testSubscript()
1747 {
1748 test_ = "CustomVector::operator[]";
1749
1750 // Assignment to the element at index 2
1751 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1752 VT vec( memory.get(), 7UL, 16UL );
1753 reset( vec );
1754 vec[2] = 1;
1755
1756 checkSize ( vec, 7UL );
1757 checkCapacity( vec, 7UL );
1758 checkNonZeros( vec, 1UL );
1759
1760 if( vec[2] != 1 ) {
1761 std::ostringstream oss;
1762 oss << " Test: " << test_ << "\n"
1763 << " Error: Subscript operator failed\n"
1764 << " Details:\n"
1765 << " Result:\n" << vec << "\n"
1766 << " Expected result:\n( 0 0 1 0 0 0 0 )\n";
1767 throw std::runtime_error( oss.str() );
1768 }
1769
1770 // Assignment to the element at index 5
1771 vec[5] = 2;
1772
1773 checkSize ( vec, 7UL );
1774 checkCapacity( vec, 7UL );
1775 checkNonZeros( vec, 2UL );
1776
1777 if( vec[2] != 1 || vec[5] != 2 ) {
1778 std::ostringstream oss;
1779 oss << " Test: " << test_ << "\n"
1780 << " Error: Subscript operator failed\n"
1781 << " Details:\n"
1782 << " Result:\n" << vec << "\n"
1783 << " Expected result:\n( 0 0 1 0 0 2 0 )\n";
1784 throw std::runtime_error( oss.str() );
1785 }
1786
1787 // Assignment to the element at index 3
1788 vec[3] = 3;
1789
1790 checkSize ( vec, 7UL );
1791 checkCapacity( vec, 7UL );
1792 checkNonZeros( vec, 3UL );
1793
1794 if( vec[2] != 1 || vec[3] != 3 || vec[5] != 2 ) {
1795 std::ostringstream oss;
1796 oss << " Test: " << test_ << "\n"
1797 << " Error: Subscript operator failed\n"
1798 << " Details:\n"
1799 << " Result:\n" << vec << "\n"
1800 << " Expected result:\n( 0 0 1 3 0 2 0 )\n";
1801 throw std::runtime_error( oss.str() );
1802 }
1803
1804 // Assignment to the element at index 0
1805 vec[0] = 4;
1806
1807 checkSize ( vec, 7UL );
1808 checkCapacity( vec, 7UL );
1809 checkNonZeros( vec, 4UL );
1810
1811 if( vec[0] != 4 || vec[2] != 1 || vec[3] != 3 || vec[5] != 2 ) {
1812 std::ostringstream oss;
1813 oss << " Test: " << test_ << "\n"
1814 << " Error: Subscript operator failed\n"
1815 << " Details:\n"
1816 << " Result:\n" << vec << "\n"
1817 << " Expected result:\n( 4 0 1 3 0 2 0 )\n";
1818 throw std::runtime_error( oss.str() );
1819 }
1820
1821 // Addition assignment to the element at index 2
1822 vec[2] += vec[3];
1823
1824 checkSize ( vec, 7UL );
1825 checkCapacity( vec, 7UL );
1826 checkNonZeros( vec, 4UL );
1827
1828 if( vec[0] != 4 || vec[2] != 4 || vec[3] != 3 || vec[5] != 2 ) {
1829 std::ostringstream oss;
1830 oss << " Test: " << test_ << "\n"
1831 << " Error: Subscript operator failed\n"
1832 << " Details:\n"
1833 << " Result:\n" << vec << "\n"
1834 << " Expected result:\n( 4 0 4 3 0 2 0 )\n";
1835 throw std::runtime_error( oss.str() );
1836 }
1837
1838 // Subtraction assignment to the element at index 1
1839 vec[1] -= vec[5];
1840
1841 checkSize ( vec, 7UL );
1842 checkCapacity( vec, 7UL );
1843 checkNonZeros( vec, 5UL );
1844
1845 if( vec[0] != 4 || vec[1] != -2 || vec[2] != 4 || vec[3] != 3 || vec[5] != 2 ) {
1846 std::ostringstream oss;
1847 oss << " Test: " << test_ << "\n"
1848 << " Error: Subscript operator failed\n"
1849 << " Details:\n"
1850 << " Result:\n" << vec << "\n"
1851 << " Expected result:\n( 4 -2 4 3 0 2 0 )\n";
1852 throw std::runtime_error( oss.str() );
1853 }
1854
1855 // Multiplication assignment to the element at index 3
1856 vec[3] *= -3;
1857
1858 checkSize ( vec, 7UL );
1859 checkCapacity( vec, 7UL );
1860 checkNonZeros( vec, 5UL );
1861
1862 if( vec[0] != 4 || vec[1] != -2 || vec[2] != 4 || vec[3] != -9 || vec[5] != 2 ) {
1863 std::ostringstream oss;
1864 oss << " Test: " << test_ << "\n"
1865 << " Error: Subscript operator failed\n"
1866 << " Details:\n"
1867 << " Result:\n" << vec << "\n"
1868 << " Expected result:\n( 4 -2 4 -9 0 2 0 )\n";
1869 throw std::runtime_error( oss.str() );
1870 }
1871
1872 // Division assignment to the element at index 2
1873 vec[2] /= 2;
1874
1875 checkSize ( vec, 7UL );
1876 checkCapacity( vec, 7UL );
1877 checkNonZeros( vec, 5UL );
1878
1879 if( vec[0] != 4 || vec[1] != -2 || vec[2] != 2 || vec[3] != -9 || vec[5] != 2 ) {
1880 std::ostringstream oss;
1881 oss << " Test: " << test_ << "\n"
1882 << " Error: Subscript operator failed\n"
1883 << " Details:\n"
1884 << " Result:\n" << vec << "\n"
1885 << " Expected result:\n( 4 -2 2 -9 0 2 0 )\n";
1886 throw std::runtime_error( oss.str() );
1887 }
1888 }
1889 //*************************************************************************************************
1890
1891
1892 //*************************************************************************************************
1893 /*!\brief Test of the \c at() member function of the CustomVector class template.
1894 //
1895 // \return void
1896 // \exception std::runtime_error Error detected.
1897 //
1898 // This function performs a test of adding and accessing elements via the subscript operator
1899 // of the CustomVector class template. In case an error is detected, a \a std::runtime_error
1900 // exception is thrown.
1901 */
testAt()1902 void UnalignedPaddedTest::testAt()
1903 {
1904 test_ = "CustomVector::at()]";
1905
1906 // Assignment to the element at index 2
1907 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
1908 VT vec( memory.get(), 7UL, 16UL );
1909 reset( vec );
1910 vec.at(2) = 1;
1911
1912 checkSize ( vec, 7UL );
1913 checkCapacity( vec, 7UL );
1914 checkNonZeros( vec, 1UL );
1915
1916 if( vec.at(2) != 1 ) {
1917 std::ostringstream oss;
1918 oss << " Test: " << test_ << "\n"
1919 << " Error: Access via at() function failed\n"
1920 << " Details:\n"
1921 << " Result:\n" << vec << "\n"
1922 << " Expected result:\n( 0 0 1 0 0 0 0 )\n";
1923 throw std::runtime_error( oss.str() );
1924 }
1925
1926 // Assignment to the element at index 5
1927 vec.at(5) = 2;
1928
1929 checkSize ( vec, 7UL );
1930 checkCapacity( vec, 7UL );
1931 checkNonZeros( vec, 2UL );
1932
1933 if( vec.at(2) != 1 || vec.at(5) != 2 ) {
1934 std::ostringstream oss;
1935 oss << " Test: " << test_ << "\n"
1936 << " Error: Access via at() function failed\n"
1937 << " Details:\n"
1938 << " Result:\n" << vec << "\n"
1939 << " Expected result:\n( 0 0 1 0 0 2 0 )\n";
1940 throw std::runtime_error( oss.str() );
1941 }
1942
1943 // Assignment to the element at index 3
1944 vec.at(3) = 3;
1945
1946 checkSize ( vec, 7UL );
1947 checkCapacity( vec, 7UL );
1948 checkNonZeros( vec, 3UL );
1949
1950 if( vec.at(2) != 1 || vec.at(3) != 3 || vec.at(5) != 2 ) {
1951 std::ostringstream oss;
1952 oss << " Test: " << test_ << "\n"
1953 << " Error: Access via at() function failed\n"
1954 << " Details:\n"
1955 << " Result:\n" << vec << "\n"
1956 << " Expected result:\n( 0 0 1 3 0 2 0 )\n";
1957 throw std::runtime_error( oss.str() );
1958 }
1959
1960 // Assignment to the element at index 0
1961 vec.at(0) = 4;
1962
1963 checkSize ( vec, 7UL );
1964 checkCapacity( vec, 7UL );
1965 checkNonZeros( vec, 4UL );
1966
1967 if( vec.at(0) != 4 || vec.at(2) != 1 || vec.at(3) != 3 || vec.at(5) != 2 ) {
1968 std::ostringstream oss;
1969 oss << " Test: " << test_ << "\n"
1970 << " Error: Access via at() function failed\n"
1971 << " Details:\n"
1972 << " Result:\n" << vec << "\n"
1973 << " Expected result:\n( 4 0 1 3 0 2 0 )\n";
1974 throw std::runtime_error( oss.str() );
1975 }
1976
1977 // Addition assignment to the element at index 2
1978 vec.at(2) += vec.at(3);
1979
1980 checkSize ( vec, 7UL );
1981 checkCapacity( vec, 7UL );
1982 checkNonZeros( vec, 4UL );
1983
1984 if( vec.at(0) != 4 || vec.at(2) != 4 || vec.at(3) != 3 || vec.at(5) != 2 ) {
1985 std::ostringstream oss;
1986 oss << " Test: " << test_ << "\n"
1987 << " Error: Access via at() function failed\n"
1988 << " Details:\n"
1989 << " Result:\n" << vec << "\n"
1990 << " Expected result:\n( 4 0 4 3 0 2 0 )\n";
1991 throw std::runtime_error( oss.str() );
1992 }
1993
1994 // Subtraction assignment to the element at index 1
1995 vec.at(1) -= vec.at(5);
1996
1997 checkSize ( vec, 7UL );
1998 checkCapacity( vec, 7UL );
1999 checkNonZeros( vec, 5UL );
2000
2001 if( vec.at(0) != 4 || vec.at(1) != -2 || vec.at(2) != 4 || vec.at(3) != 3 || vec.at(5) != 2 ) {
2002 std::ostringstream oss;
2003 oss << " Test: " << test_ << "\n"
2004 << " Error: Access via at() function failed\n"
2005 << " Details:\n"
2006 << " Result:\n" << vec << "\n"
2007 << " Expected result:\n( 4 -2 4 3 0 2 0 )\n";
2008 throw std::runtime_error( oss.str() );
2009 }
2010
2011 // Multiplication assignment to the element at index 3
2012 vec.at(3) *= -3;
2013
2014 checkSize ( vec, 7UL );
2015 checkCapacity( vec, 7UL );
2016 checkNonZeros( vec, 5UL );
2017
2018 if( vec.at(0) != 4 || vec.at(1) != -2 || vec.at(2) != 4 || vec.at(3) != -9 || vec.at(5) != 2 ) {
2019 std::ostringstream oss;
2020 oss << " Test: " << test_ << "\n"
2021 << " Error: Access via at() function failed\n"
2022 << " Details:\n"
2023 << " Result:\n" << vec << "\n"
2024 << " Expected result:\n( 4 -2 4 -9 0 2 0 )\n";
2025 throw std::runtime_error( oss.str() );
2026 }
2027
2028 // Division assignment to the element at index 2
2029 vec.at(2) /= 2;
2030
2031 checkSize ( vec, 7UL );
2032 checkCapacity( vec, 7UL );
2033 checkNonZeros( vec, 5UL );
2034
2035 if( vec.at(0) != 4 || vec.at(1) != -2 || vec.at(2) != 2 || vec.at(3) != -9 || vec.at(5) != 2 ) {
2036 std::ostringstream oss;
2037 oss << " Test: " << test_ << "\n"
2038 << " Error: Access via at() function failed\n"
2039 << " Details:\n"
2040 << " Result:\n" << vec << "\n"
2041 << " Expected result:\n( 4 -2 2 -9 0 2 0 )\n";
2042 throw std::runtime_error( oss.str() );
2043 }
2044
2045 // Attempt to assign to the element at index 7
2046 try {
2047 vec.at(7) = 2;
2048
2049 std::ostringstream oss;
2050 oss << " Test: " << test_ << "\n"
2051 << " Error: Out-of-bound access succeeded\n"
2052 << " Details:\n"
2053 << " Result:\n" << vec << "\n"
2054 << " Expected result:\n( 4 -2 2 -9 0 2 0 )\n";
2055 throw std::runtime_error( oss.str() );
2056 }
2057 catch( std::out_of_range& ) {}
2058 }
2059 //*************************************************************************************************
2060
2061
2062 //*************************************************************************************************
2063 /*!\brief Test of the CustomVector iterator implementation.
2064 //
2065 // \return void
2066 // \exception std::runtime_error Error detected.
2067 //
2068 // This function performs a test of the iterator implementation of the CustomVector class
2069 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2070 */
testIterator()2071 void UnalignedPaddedTest::testIterator()
2072 {
2073 using Iterator = VT::Iterator;
2074 using ConstIterator = VT::ConstIterator;
2075
2076 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2077 VT vec( memory.get(), 4UL, 16UL );
2078 vec[0] = 1;
2079 vec[1] = 0;
2080 vec[2] = -2;
2081 vec[3] = -3;
2082
2083 // Testing the Iterator default constructor
2084 {
2085 test_ = "Iterator default constructor";
2086
2087 Iterator it{};
2088
2089 if( it != Iterator() ) {
2090 std::ostringstream oss;
2091 oss << " Test: " << test_ << "\n"
2092 << " Error: Failed iterator default constructor\n";
2093 throw std::runtime_error( oss.str() );
2094 }
2095 }
2096
2097 // Testing the ConstIterator default constructor
2098 {
2099 test_ = "ConstIterator default constructor";
2100
2101 ConstIterator it{};
2102
2103 if( it != ConstIterator() ) {
2104 std::ostringstream oss;
2105 oss << " Test: " << test_ << "\n"
2106 << " Error: Failed iterator default constructor\n";
2107 throw std::runtime_error( oss.str() );
2108 }
2109 }
2110
2111 // Testing conversion from Iterator to ConstIterator
2112 {
2113 test_ = "Iterator/ConstIterator conversion";
2114
2115 ConstIterator it( begin( vec ) );
2116
2117 if( it == end( vec ) || *it != 1 ) {
2118 std::ostringstream oss;
2119 oss << " Test: " << test_ << "\n"
2120 << " Error: Failed iterator conversion detected\n";
2121 throw std::runtime_error( oss.str() );
2122 }
2123 }
2124
2125 // Counting the number of elements via Iterator (end-begin)
2126 {
2127 test_ = "Iterator subtraction (end-begin)";
2128
2129 const ptrdiff_t number( end( vec ) - begin( vec ) );
2130
2131 if( number != 4L ) {
2132 std::ostringstream oss;
2133 oss << " Test: " << test_ << "\n"
2134 << " Error: Invalid number of elements detected\n"
2135 << " Details:\n"
2136 << " Number of elements : " << number << "\n"
2137 << " Expected number of elements: 4\n";
2138 throw std::runtime_error( oss.str() );
2139 }
2140 }
2141
2142 // Counting the number of elements via Iterator (begin-end)
2143 {
2144 test_ = "Iterator subtraction (begin-end)";
2145
2146 const ptrdiff_t number( begin( vec ) - end( vec ) );
2147
2148 if( number != -4L ) {
2149 std::ostringstream oss;
2150 oss << " Test: " << test_ << "\n"
2151 << " Error: Invalid number of elements detected\n"
2152 << " Details:\n"
2153 << " Number of elements : " << number << "\n"
2154 << " Expected number of elements: -4\n";
2155 throw std::runtime_error( oss.str() );
2156 }
2157 }
2158
2159 // Counting the number of elements via ConstIterator (end-begin)
2160 {
2161 test_ = "ConstIterator subtraction (end-begin)";
2162
2163 const ptrdiff_t number( cend( vec ) - cbegin( vec ) );
2164
2165 if( number != 4L ) {
2166 std::ostringstream oss;
2167 oss << " Test: " << test_ << "\n"
2168 << " Error: Invalid number of elements detected\n"
2169 << " Details:\n"
2170 << " Number of elements : " << number << "\n"
2171 << " Expected number of elements: 4\n";
2172 throw std::runtime_error( oss.str() );
2173 }
2174 }
2175
2176 // Counting the number of elements via ConstIterator (begin-end)
2177 {
2178 test_ = "ConstIterator subtraction (begin-end)";
2179
2180 const ptrdiff_t number( cbegin( vec ) - cend( vec ) );
2181
2182 if( number != -4L ) {
2183 std::ostringstream oss;
2184 oss << " Test: " << test_ << "\n"
2185 << " Error: Invalid number of elements detected\n"
2186 << " Details:\n"
2187 << " Number of elements : " << number << "\n"
2188 << " Expected number of elements: -4\n";
2189 throw std::runtime_error( oss.str() );
2190 }
2191 }
2192
2193 // Testing read-only access via ConstIterator
2194 {
2195 test_ = "Read-only access via ConstIterator";
2196
2197 ConstIterator it ( cbegin( vec ) );
2198 ConstIterator end( cend( vec ) );
2199
2200 if( it == end || *it != 1 ) {
2201 std::ostringstream oss;
2202 oss << " Test: " << test_ << "\n"
2203 << " Error: Invalid initial iterator detected\n";
2204 throw std::runtime_error( oss.str() );
2205 }
2206
2207 ++it;
2208
2209 if( it == end || *it != 0 ) {
2210 std::ostringstream oss;
2211 oss << " Test: " << test_ << "\n"
2212 << " Error: Iterator pre-increment failed\n";
2213 throw std::runtime_error( oss.str() );
2214 }
2215
2216 --it;
2217
2218 if( it == end || *it != 1 ) {
2219 std::ostringstream oss;
2220 oss << " Test: " << test_ << "\n"
2221 << " Error: Iterator pre-decrement failed\n";
2222 throw std::runtime_error( oss.str() );
2223 }
2224
2225 it++;
2226
2227 if( it == end || *it != 0 ) {
2228 std::ostringstream oss;
2229 oss << " Test: " << test_ << "\n"
2230 << " Error: Iterator post-increment failed\n";
2231 throw std::runtime_error( oss.str() );
2232 }
2233
2234 it--;
2235
2236 if( it == end || *it != 1 ) {
2237 std::ostringstream oss;
2238 oss << " Test: " << test_ << "\n"
2239 << " Error: Iterator post-decrement failed\n";
2240 throw std::runtime_error( oss.str() );
2241 }
2242
2243 it += 2UL;
2244
2245 if( it == end || *it != -2 ) {
2246 std::ostringstream oss;
2247 oss << " Test: " << test_ << "\n"
2248 << " Error: Iterator addition assignment failed\n";
2249 throw std::runtime_error( oss.str() );
2250 }
2251
2252 it -= 2UL;
2253
2254 if( it == end || *it != 1 ) {
2255 std::ostringstream oss;
2256 oss << " Test: " << test_ << "\n"
2257 << " Error: Iterator subtraction assignment failed\n";
2258 throw std::runtime_error( oss.str() );
2259 }
2260
2261 it = it + 3UL;
2262
2263 if( it == end || *it != -3 ) {
2264 std::ostringstream oss;
2265 oss << " Test: " << test_ << "\n"
2266 << " Error: Iterator/scalar addition failed\n";
2267 throw std::runtime_error( oss.str() );
2268 }
2269
2270 it = it - 3UL;
2271
2272 if( it == end || *it != 1 ) {
2273 std::ostringstream oss;
2274 oss << " Test: " << test_ << "\n"
2275 << " Error: Iterator/scalar subtraction failed\n";
2276 throw std::runtime_error( oss.str() );
2277 }
2278
2279 it = 4UL + it;
2280
2281 if( it != end ) {
2282 std::ostringstream oss;
2283 oss << " Test: " << test_ << "\n"
2284 << " Error: Scalar/iterator addition failed\n";
2285 throw std::runtime_error( oss.str() );
2286 }
2287 }
2288
2289 // Testing assignment via Iterator
2290 {
2291 test_ = "Assignment via Iterator";
2292
2293 int value = 6;
2294
2295 for( Iterator it=begin( vec ); it!=end( vec ); ++it ) {
2296 *it = value++;
2297 }
2298
2299 if( vec[0] != 6 || vec[1] != 7 || vec[2] != 8 || vec[3] != 9 ) {
2300 std::ostringstream oss;
2301 oss << " Test: " << test_ << "\n"
2302 << " Error: Assignment via iterator failed\n"
2303 << " Details:\n"
2304 << " Result:\n" << vec << "\n"
2305 << " Expected result:\n( 6 7 8 9 )\n";
2306 throw std::runtime_error( oss.str() );
2307 }
2308 }
2309
2310 // Testing addition assignment via Iterator
2311 {
2312 test_ = "Addition assignment via Iterator";
2313
2314 int value = 2;
2315
2316 for( Iterator it=begin( vec ); it!=end( vec ); ++it ) {
2317 *it += value++;
2318 }
2319
2320 if( vec[0] != 8 || vec[1] != 10 || vec[2] != 12 || vec[3] != 14 ) {
2321 std::ostringstream oss;
2322 oss << " Test: " << test_ << "\n"
2323 << " Error: Addition assignment via iterator failed\n"
2324 << " Details:\n"
2325 << " Result:\n" << vec << "\n"
2326 << " Expected result:\n( 8 10 12 14 )\n";
2327 throw std::runtime_error( oss.str() );
2328 }
2329 }
2330
2331 // Testing subtraction assignment via Iterator
2332 {
2333 test_ = "Subtraction assignment via Iterator";
2334
2335 int value = 2;
2336
2337 for( Iterator it=begin( vec ); it!=end( vec ); ++it ) {
2338 *it -= value++;
2339 }
2340
2341 if( vec[0] != 6 || vec[1] != 7 || vec[2] != 8 || vec[3] != 9 ) {
2342 std::ostringstream oss;
2343 oss << " Test: " << test_ << "\n"
2344 << " Error: Subtraction assignment via iterator failed\n"
2345 << " Details:\n"
2346 << " Result:\n" << vec << "\n"
2347 << " Expected result:\n( 6 7 8 9 )\n";
2348 throw std::runtime_error( oss.str() );
2349 }
2350 }
2351
2352 // Testing multiplication assignment via Iterator
2353 {
2354 test_ = "Multiplication assignment via Iterator";
2355
2356 int value = 1;
2357
2358 for( Iterator it=begin( vec ); it!=end( vec ); ++it ) {
2359 *it *= value++;
2360 }
2361
2362 if( vec[0] != 6 || vec[1] != 14 || vec[2] != 24 || vec[3] != 36 ) {
2363 std::ostringstream oss;
2364 oss << " Test: " << test_ << "\n"
2365 << " Error: Multiplication assignment via iterator failed\n"
2366 << " Details:\n"
2367 << " Result:\n" << vec << "\n"
2368 << " Expected result:\n( 6 14 24 36 )\n";
2369 throw std::runtime_error( oss.str() );
2370 }
2371 }
2372
2373 // Testing division assignment via Iterator
2374 {
2375 test_ = "Division assignment via Iterator";
2376
2377 for( Iterator it=begin( vec ); it!=end( vec ); ++it ) {
2378 *it /= 2;
2379 }
2380
2381 if( vec[0] != 3 || vec[1] != 7 || vec[2] != 12 || vec[3] != 18 ) {
2382 std::ostringstream oss;
2383 oss << " Test: " << test_ << "\n"
2384 << " Error: Division assignment via iterator failed\n"
2385 << " Details:\n"
2386 << " Result:\n" << vec << "\n"
2387 << " Expected result:\n( 3 7 12 18 )\n";
2388 throw std::runtime_error( oss.str() );
2389 }
2390 }
2391 }
2392 //*************************************************************************************************
2393
2394
2395 //*************************************************************************************************
2396 /*!\brief Test of the \c nonZeros() member function of the CustomVector class template.
2397 //
2398 // \return void
2399 // \exception std::runtime_error Error detected.
2400 //
2401 // This function performs a test of the \c nonZeros() member function of the CustomVector class
2402 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2403 */
testNonZeros()2404 void UnalignedPaddedTest::testNonZeros()
2405 {
2406 test_ = "CustomVector::nonZeros()";
2407
2408 {
2409 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2410 VT vec( memory.get(), 4UL, 16UL );
2411 reset( vec );
2412
2413 checkSize ( vec, 4UL );
2414 checkCapacity( vec, 4UL );
2415 checkNonZeros( vec, 0UL );
2416
2417 if( vec[0] != 0 || vec[1] != 0 || vec[2] != 0 || vec[3] != 0 ) {
2418 std::ostringstream oss;
2419 oss << " Test: " << test_ << "\n"
2420 << " Error: Initialization failed\n"
2421 << " Details:\n"
2422 << " Result:\n" << vec << "\n"
2423 << " Expected result:\n( 0 0 0 0 )\n";
2424 throw std::runtime_error( oss.str() );
2425 }
2426 }
2427
2428 {
2429 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2430 VT vec( memory.get(), 4UL, 16UL );
2431 vec[0] = 1;
2432 vec[1] = 2;
2433 vec[2] = 0;
2434 vec[3] = 3;
2435
2436 checkSize ( vec, 4UL );
2437 checkCapacity( vec, 4UL );
2438 checkNonZeros( vec, 3UL );
2439
2440 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 0 || vec[3] != 3 ) {
2441 std::ostringstream oss;
2442 oss << " Test: " << test_ << "\n"
2443 << " Error: Initialization failed\n"
2444 << " Details:\n"
2445 << " Result:\n" << vec << "\n"
2446 << " Expected result:\n( 1 2 0 3 )\n";
2447 throw std::runtime_error( oss.str() );
2448 }
2449 }
2450 }
2451 //*************************************************************************************************
2452
2453
2454 //*************************************************************************************************
2455 /*!\brief Test of the \c reset() member function of the CustomVector class template.
2456 //
2457 // \return void
2458 // \exception std::runtime_error Error detected.
2459 //
2460 // This function performs a test of the \c reset() member function of the CustomVector class
2461 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2462 */
testReset()2463 void UnalignedPaddedTest::testReset()
2464 {
2465 using blaze::reset;
2466
2467
2468 //=====================================================================================
2469 // CustomVector::reset()
2470 //=====================================================================================
2471
2472 {
2473 test_ = "CustomVector::reset()";
2474
2475 // Initialization check
2476 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2477 VT vec( memory.get(), 4UL, 16UL );
2478 vec[0] = 1;
2479 vec[1] = 2;
2480 vec[2] = 3;
2481 vec[3] = 4;
2482
2483 checkSize ( vec, 4UL );
2484 checkCapacity( vec, 4UL );
2485 checkNonZeros( vec, 4UL );
2486
2487 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
2488 std::ostringstream oss;
2489 oss << " Test: " << test_ << "\n"
2490 << " Error: Initialization failed\n"
2491 << " Details:\n"
2492 << " Result:\n" << vec << "\n"
2493 << " Expected result:\n( 1 2 3 4 )\n";
2494 throw std::runtime_error( oss.str() );
2495 }
2496
2497 // Resetting a single element
2498 reset( vec[2] );
2499
2500 checkSize ( vec, 4UL );
2501 checkCapacity( vec, 4UL );
2502 checkNonZeros( vec, 3UL );
2503
2504 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 0 || vec[3] != 4 ) {
2505 std::ostringstream oss;
2506 oss << " Test: " << test_ << "\n"
2507 << " Error: Reset operation failed\n"
2508 << " Details:\n"
2509 << " Result:\n" << vec << "\n"
2510 << " Expected result:\n( 1 2 0 4 )\n";
2511 throw std::runtime_error( oss.str() );
2512 }
2513
2514 // Resetting the vector
2515 reset( vec );
2516
2517 checkSize ( vec, 4UL );
2518 checkCapacity( vec, 4UL );
2519 checkNonZeros( vec, 0UL );
2520
2521 if( vec[0] != 0 || vec[1] != 0 || vec[2] != 0 || vec[3] != 0 ) {
2522 std::ostringstream oss;
2523 oss << " Test: " << test_ << "\n"
2524 << " Error: Reset operation failed\n"
2525 << " Details:\n"
2526 << " Result:\n" << vec << "\n"
2527 << " Expected result:\n( 0 0 0 0 )\n";
2528 throw std::runtime_error( oss.str() );
2529 }
2530 }
2531
2532
2533 //=====================================================================================
2534 // CustomVector::reset( Type*, size_t, size_t )
2535 //=====================================================================================
2536
2537 {
2538 test_ = "CustomVector::reset( Type*, size_t, size_t )";
2539
2540 std::unique_ptr<int[],blaze::ArrayDelete> memory1( new int[16UL] );
2541 VT vec( memory1.get(), 4UL, 16UL );
2542 vec[0] = 1;
2543 vec[1] = 2;
2544 vec[2] = 3;
2545 vec[3] = 4;
2546
2547 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[32UL] );
2548 vec.reset( memory2.get(), 27UL, 32UL );
2549
2550 checkSize ( vec, 27UL );
2551 checkCapacity( vec, 32UL );
2552 }
2553 }
2554 //*************************************************************************************************
2555
2556
2557 //*************************************************************************************************
2558 /*!\brief Test of the \c clear() member function of the CustomVector class template.
2559 //
2560 // \return void
2561 // \exception std::runtime_error Error detected.
2562 //
2563 // This function performs a test of the \c clear() member function of the CustomVector class
2564 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2565 */
testClear()2566 void UnalignedPaddedTest::testClear()
2567 {
2568 using blaze::clear;
2569
2570 test_ = "CustomVector::clear()";
2571
2572 // Initialization check
2573 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2574 VT vec( memory.get(), 4UL, 16UL );
2575 vec[0] = 1;
2576 vec[1] = 2;
2577 vec[2] = 3;
2578 vec[3] = 4;
2579
2580 checkSize ( vec, 4UL );
2581 checkCapacity( vec, 4UL );
2582 checkNonZeros( vec, 4UL );
2583
2584 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ) {
2585 std::ostringstream oss;
2586 oss << " Test: " << test_ << "\n"
2587 << " Error: Initialization failed\n"
2588 << " Details:\n"
2589 << " Result:\n" << vec << "\n"
2590 << " Expected result:\n( 1 2 3 4 )\n";
2591 throw std::runtime_error( oss.str() );
2592 }
2593
2594 // Clearing a single element
2595 clear( vec[2] );
2596
2597 checkSize ( vec, 4UL );
2598 checkCapacity( vec, 4UL );
2599 checkNonZeros( vec, 3UL );
2600
2601 if( vec[0] != 1 || vec[1] != 2 || vec[2] != 0 || vec[3] != 4 ) {
2602 std::ostringstream oss;
2603 oss << " Test: " << test_ << "\n"
2604 << " Error: Clear operation failed\n"
2605 << " Details:\n"
2606 << " Result:\n" << vec << "\n"
2607 << " Expected result:\n( 1 2 0 4 )\n";
2608 throw std::runtime_error( oss.str() );
2609 }
2610
2611 // Clearing the vector
2612 clear( vec );
2613
2614 checkSize ( vec, 0UL );
2615 checkNonZeros( vec, 0UL );
2616 }
2617 //*************************************************************************************************
2618
2619
2620 //*************************************************************************************************
2621 /*!\brief Test of the \c swap() functionality of the CustomVector class template.
2622 //
2623 // \return void
2624 // \exception std::runtime_error Error detected.
2625 //
2626 // This function performs a test of the \c swap() function of the CustomVector class template.
2627 // In case an error is detected, a \a std::runtime_error exception is thrown.
2628 */
testSwap()2629 void UnalignedPaddedTest::testSwap()
2630 {
2631 test_ = "CustomVector swap";
2632
2633 std::unique_ptr<int[],blaze::ArrayDelete> memory1( new int[16UL] );
2634 VT vec1( memory1.get(), 3UL, 16UL );
2635 vec1[0] = 1;
2636 vec1[1] = 2;
2637 vec1[2] = 3;
2638
2639 std::unique_ptr<int[],blaze::ArrayDelete> memory2( new int[16UL] );
2640 VT vec2( memory2.get(), 4UL, 16UL );
2641 vec2[0] = 4;
2642 vec2[1] = 3;
2643 vec2[2] = 2;
2644 vec2[3] = 1;
2645
2646 swap( vec1, vec2 );
2647
2648 checkSize ( vec1, 4UL );
2649 checkCapacity( vec1, 4UL );
2650 checkNonZeros( vec1, 4UL );
2651
2652 if( vec1[0] != 4 || vec1[1] != 3 || vec1[2] != 2 || vec1[3] != 1 ) {
2653 std::ostringstream oss;
2654 oss << " Test: " << test_ << "\n"
2655 << " Error: Swapping the first vector failed\n"
2656 << " Details:\n"
2657 << " Result:\n" << vec1 << "\n"
2658 << " Expected result:\n( 4 3 2 1 )\n";
2659 throw std::runtime_error( oss.str() );
2660 }
2661
2662 checkSize ( vec2, 3UL );
2663 checkCapacity( vec2, 3UL );
2664 checkNonZeros( vec2, 3UL );
2665
2666 if( vec2[0] != 1 || vec2[1] != 2 || vec2[2] != 3 ) {
2667 std::ostringstream oss;
2668 oss << " Test: " << test_ << "\n"
2669 << " Error: Swapping the second vector failed\n"
2670 << " Details:\n"
2671 << " Result:\n" << vec1 << "\n"
2672 << " Expected result:\n( 1 2 3 )\n";
2673 throw std::runtime_error( oss.str() );
2674 }
2675 }
2676 //*************************************************************************************************
2677
2678
2679 //*************************************************************************************************
2680 /*!\brief Test of the \c isDefault() function with the CustomVector class template.
2681 //
2682 // \return void
2683 // \exception std::runtime_error Error detected.
2684 //
2685 // This function performs a test of the \c isDefault() function with the CustomVector class
2686 // template. In case an error is detected, a \a std::runtime_error exception is thrown.
2687 */
testIsDefault()2688 void UnalignedPaddedTest::testIsDefault()
2689 {
2690 using blaze::isDefault;
2691
2692 test_ = "isDefault() function";
2693
2694 // isDefault with vector of size 0
2695 {
2696 VT vec;
2697
2698 if( isDefault( vec ) != true ) {
2699 std::ostringstream oss;
2700 oss << " Test: " << test_ << "\n"
2701 << " Error: Invalid isDefault evaluation\n"
2702 << " Details:\n"
2703 << " Vector:\n" << vec << "\n";
2704 throw std::runtime_error( oss.str() );
2705 }
2706 }
2707
2708 // isDefault with default vector
2709 {
2710 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2711 VT vec( memory.get(), 3UL, 16UL );
2712 reset( vec );
2713
2714 if( isDefault( vec[1] ) != true ) {
2715 std::ostringstream oss;
2716 oss << " Test: " << test_ << "\n"
2717 << " Error: Invalid isDefault evaluation\n"
2718 << " Details:\n"
2719 << " Vector element: " << vec[1] << "\n";
2720 throw std::runtime_error( oss.str() );
2721 }
2722
2723 if( isDefault( vec ) != false ) {
2724 std::ostringstream oss;
2725 oss << " Test: " << test_ << "\n"
2726 << " Error: Invalid isDefault evaluation\n"
2727 << " Details:\n"
2728 << " Vector:\n" << vec << "\n";
2729 throw std::runtime_error( oss.str() );
2730 }
2731 }
2732
2733 // isDefault with non-default vector
2734 {
2735 std::unique_ptr<int[],blaze::ArrayDelete> memory( new int[16UL] );
2736 VT vec( memory.get(), 3UL, 16UL );
2737 reset( vec );
2738 vec[1] = 1;
2739
2740 if( isDefault( vec[1] ) != false ) {
2741 std::ostringstream oss;
2742 oss << " Test: " << test_ << "\n"
2743 << " Error: Invalid isDefault evaluation\n"
2744 << " Details:\n"
2745 << " Vector element: " << vec[1] << "\n";
2746 throw std::runtime_error( oss.str() );
2747 }
2748
2749 if( isDefault( vec ) != false ) {
2750 std::ostringstream oss;
2751 oss << " Test: " << test_ << "\n"
2752 << " Error: Invalid isDefault evaluation\n"
2753 << " Details:\n"
2754 << " Vector:\n" << vec << "\n";
2755 throw std::runtime_error( oss.str() );
2756 }
2757 }
2758 }
2759 //*************************************************************************************************
2760
2761 } // namespace customvector
2762
2763 } // namespace vectors
2764
2765 } // namespace mathtest
2766
2767 } // namespace blazetest
2768
2769
2770
2771
2772 //=================================================================================================
2773 //
2774 // MAIN FUNCTION
2775 //
2776 //=================================================================================================
2777
2778 //*************************************************************************************************
main()2779 int main()
2780 {
2781 std::cout << " Running unaligned/padded CustomVector class test..." << std::endl;
2782
2783 try
2784 {
2785 RUN_CUSTOMVECTOR_UNALIGNED_PADDED_TEST;
2786 }
2787 catch( std::exception& ex ) {
2788 std::cerr << "\n\n ERROR DETECTED during unaligned/padded CustomVector class test:\n"
2789 << ex.what() << "\n";
2790 return EXIT_FAILURE;
2791 }
2792
2793 return EXIT_SUCCESS;
2794 }
2795 //*************************************************************************************************
2796