Nektar++
Typedefs | Functions
Nektar::SimdLibTests Namespace Reference

Typedefs

using vec_t = simd< double >
 

Functions

 BOOST_AUTO_TEST_CASE (SimdLibDouble_width_alignment)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_type_traits)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_mem_size)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_ctors)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_load)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_load_implicit)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_load_aligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_load_unaligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibInt64_load)
 
 BOOST_AUTO_TEST_CASE (SimdLibInt64_load_aligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibInt64_load_unaligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibInt32_load)
 
 BOOST_AUTO_TEST_CASE (SimdLibInt32_load_aligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibInt32_load_unaligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_store)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_store_aligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_store_unaligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_store_non_temporal)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_broadcast)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_subscript_assign_read)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_gather64)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_gather32)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_scatter64)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_add_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_sub_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_mul_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_div_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_add_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_sub_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_mul_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_div_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_add_mul)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_fused_add_mul)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_sqrt)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_abs)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_log)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_greater)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_logic_and)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_load_interleave_unload)
 
 BOOST_AUTO_TEST_CASE (SimdLibDouble_io)
 
 BOOST_AUTO_TEST_CASE (SimdLibSingle_width_alignment)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_type_traits)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_mem_size)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_ctors)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_load)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_load_implicit)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_load_aligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_load_unaligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_store)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_store_aligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_store_unaligned)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_store_non_temporal)
 
 BOOST_AUTO_TEST_CASE (SimdLibSingle_broadcast)
 
 BOOST_AUTO_TEST_CASE (SimdLibSingle_subscript_assign_read)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_gather32)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_scatter32)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_add_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_sub_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_mul_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_div_unary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_add_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_sub_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_mul_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_div_binary)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_add_mul)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_fused_add_mul)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_sqrt)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_abs)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_log)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_greater)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_logic_and)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_load_interleave_unload)
 
 BOOST_AUTO_TEST_CASE (SimdLibFloat_io)
 

Typedef Documentation

◆ vec_t

typedef simd< float > Nektar::SimdLibTests::vec_t

Definition at line 88 of file TestSimdLibDouble.cpp.

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_abs  )

Definition at line 683 of file TestSimdLibDouble.cpp.

684{
685 double val = -4.0;
686 vec_t avec(val);
687 vec_t aabs = abs(avec);
688 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
689 {}}; // double brace to deal with gcc 4.8.5 ...
690 aabs.store(ascalararr.data());
691
692 for (size_t i = 0; i < vec_t::width; ++i)
693 {
694 BOOST_CHECK_EQUAL(ascalararr[i], std::abs(val));
695 }
696}
tinysimd::abs
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:298

References tinysimd::abs().

◆ BOOST_AUTO_TEST_CASE() [2/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_add_binary  )

Definition at line 562 of file TestSimdLibDouble.cpp.

563{
564 double val1 = -4.0;
565 double val2 = 2.5;
566 vec_t avec1(val1);
567 vec_t avec2(val2);
568 vec_t res = avec1 + avec2;
569 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
570 {}}; // double brace to deal with gcc 4.8.5 ...
571 res.store(ascalararr.data());
572
573 for (size_t i = 0; i < vec_t::width; ++i)
574 {
575 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
576 }
577}

◆ BOOST_AUTO_TEST_CASE() [3/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_add_mul  )

Definition at line 630 of file TestSimdLibDouble.cpp.

631{
632 double val1 = -4.0;
633 double val2 = 1.5;
634 double val3 = 5.0;
635 vec_t avec1(val1);
636 vec_t avec2(val2);
637 vec_t avec3(val3);
638 vec_t res = avec1 + avec2 * avec3;
639 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
640 {}}; // double brace to deal with gcc 4.8.5 ...
641 res.store(ascalararr.data());
642
643 for (size_t i = 0; i < vec_t::width; ++i)
644 {
645 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 * val3);
646 }
647}

◆ BOOST_AUTO_TEST_CASE() [4/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_add_unary  )

Definition at line 494 of file TestSimdLibDouble.cpp.

495{
496 double val1 = -4.0;
497 double val2 = 2.0;
498 vec_t res(val1);
499 vec_t avec(val2);
500 res += avec;
501 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
502 {}}; // double brace to deal with gcc 4.8.5 ...
503 res.store(ascalararr.data());
504
505 for (size_t i = 0; i < vec_t::width; ++i)
506 {
507 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
508 }
509}

◆ BOOST_AUTO_TEST_CASE() [5/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_broadcast  )

Definition at line 315 of file TestSimdLibDouble.cpp.

316{
317 vec_t::scalarType ascalar{3.333};
318 vec_t avec;
319 avec.broadcast(ascalar);
320}
Nektar::vec_t
tinysimd::simd< NekDouble > vec_t
Definition: EquationOfState.h:59

◆ BOOST_AUTO_TEST_CASE() [6/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_ctors  )

Definition at line 156 of file TestSimdLibDouble.cpp.

157{
158 vec_t avec1;
159
160 vec_t::scalarType ascalar = 0;
161 vec_t avec2(ascalar);
162 vec_t avec3{ascalar};
163 vec_t avec4 = ascalar;
164
165 vec_t avec5(avec2);
166 vec_t avec6{avec4};
167
168 vec_t avec7(avec2._data);
169 vec_t avec8{avec2._data};
170
171 vec_t::vectorType anative;
172 vec_t avec9(anative);
173 vec_t avec10{anative};
174
175 boost::ignore_unused(avec1, avec3, avec5, avec6, avec7, avec8, avec9,
176 avec10);
177}

◆ BOOST_AUTO_TEST_CASE() [7/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_div_binary  )

Definition at line 613 of file TestSimdLibDouble.cpp.

614{
615 double val1 = -4.0;
616 double val2 = 2.5;
617 vec_t avec1(val1);
618 vec_t avec2(val2);
619 vec_t res = avec1 / avec2;
620 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
621 {}}; // double brace to deal with gcc 4.8.5 ...
622 res.store(ascalararr.data());
623
624 for (size_t i = 0; i < vec_t::width; ++i)
625 {
626 BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
627 }
628}

◆ BOOST_AUTO_TEST_CASE() [8/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_div_unary  )

Definition at line 545 of file TestSimdLibDouble.cpp.

546{
547 double val1 = -4.0;
548 double val2 = 2.0;
549 vec_t res(val1);
550 vec_t avec(val2);
551 res /= avec;
552 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
553 {}}; // double brace to deal with gcc 4.8.5 ...
554 res.store(ascalararr.data());
555
556 for (size_t i = 0; i < vec_t::width; ++i)
557 {
558 BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
559 }
560}

◆ BOOST_AUTO_TEST_CASE() [9/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_fused_add_mul  )

Definition at line 649 of file TestSimdLibDouble.cpp.

650{
651 double val1 = -4.0;
652 double val2 = 1.5;
653 double val3 = 5.0;
654 vec_t avec1(val1);
655 vec_t avec2(val2);
656 vec_t avec3(val3);
657 avec1.fma(avec2, avec3);
658 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
659 {}}; // double brace to deal with gcc 4.8.5 ...
660 avec1.store(ascalararr.data());
661
662 for (size_t i = 0; i < vec_t::width; ++i)
663 {
664 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 * val3);
665 }
666}

◆ BOOST_AUTO_TEST_CASE() [10/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_gather32  )

Definition at line 387 of file TestSimdLibDouble.cpp.

388{
389 vec_t avec;
390 using index_t = simd<std::uint32_t, vec_t::width>;
391 index_t aindexvec;
392
393 // create and fill index
394 std::array<std::uint32_t, vec_t::width> aindex;
395 aindex[0] = 0;
396 if (vec_t::width > 2)
397 {
398 aindex[1] = 3;
399 aindex[2] = 5;
400 aindex[3] = 6;
401 }
402 if (vec_t::width > 4)
403 {
404 aindex[4] = 8;
405 aindex[5] = 15;
406 aindex[6] = 16;
407 aindex[7] = 20;
408 }
409
410 // load index
411 aindexvec.load(aindex.data(), is_not_aligned);
412
413 // create and fill scalar array
414 constexpr size_t scalarArraySize = 32;
415 std::array<double, scalarArraySize> ascalararr;
416 for (size_t i = 0; i < scalarArraySize; ++i)
417 {
418 ascalararr[i] = i;
419 }
420
421 avec.gather(ascalararr.data(), aindexvec);
422
423 // check
424 for (size_t i = 0; i < vec_t::width; ++i)
425 {
426 BOOST_CHECK_EQUAL(ascalararr[aindex[i]], avec[i]);
427 }
428}
tinysimd::is_not_aligned
static constexpr struct tinysimd::is_not_aligned_t is_not_aligned
tinysimd::simd
typename abi< ScalarType, width >::type simd
Definition: tinysimd.hpp:80

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [11/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_gather64  )

Definition at line 344 of file TestSimdLibDouble.cpp.

345{
346 vec_t avec;
347 using index_t = simd<size_t>;
348 index_t aindexvec;
349
350 // create and fill index
351 std::array<size_t, vec_t::width> aindex;
352 aindex[0] = 0;
353 if (vec_t::width > 2)
354 {
355 aindex[1] = 3;
356 aindex[2] = 5;
357 aindex[3] = 6;
358 }
359 if (vec_t::width > 4)
360 {
361 aindex[4] = 8;
362 aindex[5] = 15;
363 aindex[6] = 16;
364 aindex[7] = 20;
365 }
366
367 // load index
368 aindexvec.load(aindex.data(), is_not_aligned);
369
370 // create and fill scalar array
371 constexpr size_t scalarArraySize = 32;
372 std::array<double, scalarArraySize> ascalararr;
373 for (size_t i = 0; i < scalarArraySize; ++i)
374 {
375 ascalararr[i] = i;
376 }
377
378 avec.gather(ascalararr.data(), aindexvec);
379
380 // check
381 for (size_t i = 0; i < vec_t::width; ++i)
382 {
383 BOOST_CHECK_EQUAL(ascalararr[aindex[i]], avec[i]);
384 }
385}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [12/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_greater  )

Definition at line 713 of file TestSimdLibDouble.cpp.

714{
715 double aval = 4.0;
716 vec_t avec(aval);
717 using mask_t = simd<bool, vec_t::width>;
718 mask_t amask;
719
720 amask = avec > avec;
721 // check
722 alignas(vec_t::alignment) std::array<std::uint64_t, vec_t::width>
723 ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
724 amask.store(ascalararr.data());
725 for (size_t i = 0; i < vec_t::width; ++i)
726 {
727 // type conversion make lvalue in rvalue, needed pre-c++17
728 BOOST_CHECK_EQUAL(ascalararr[i], (std::uint64_t)mask_t::false_v);
729 }
730
731 double bval = 3.0;
732 vec_t bvec(bval);
733
734 amask = avec > bvec;
735 // check
736 amask.store(ascalararr.data());
737 for (size_t i = 0; i < vec_t::width; ++i)
738 {
739 // type conversion make lvalue in rvalue, needed pre-c++17
740 BOOST_CHECK_EQUAL(ascalararr[i], (std::uint64_t)mask_t::true_v);
741 }
742
743 double cval = 5.0;
744 vec_t cvec(cval);
745
746 amask = avec > cvec;
747 // check
748 amask.store(ascalararr.data());
749 for (size_t i = 0; i < vec_t::width; ++i)
750 {
751 // type conversion make lvalue in rvalue, needed pre-c++17
752 BOOST_CHECK_EQUAL(ascalararr[i], (std::uint64_t)mask_t::false_v);
753 }
754
755 if (vec_t::width == 4)
756 {
757 alignas(vec_t::alignment) std::array<double, 4> ascalararr2{
758 {1.0, 2.0, 3.0, 4.0}}; // double brace to deal with gcc 4.8.5 ...
759 double dval = 2.0;
760 vec_t dvec(dval);
761 vec_t evec;
762 evec.load(ascalararr2.data());
763
764 amask = dvec > evec;
765 // check
766 for (size_t i = 0; i < vec_t::width; ++i)
767 {
768 BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]),
769 dval > ascalararr2[i]);
770 }
771 }
772
773 if (vec_t::width == 8)
774 {
775 alignas(vec_t::alignment) std::array<double, 8> ascalararr2{
776 {1.0, 2.0, 3.0, 4.0, 3.0, 2.0,
777 1.0}}; // double brace to deal with gcc 4.8.5 ...
778 double dval = 2.0;
779 vec_t dvec(dval);
780 vec_t evec;
781 evec.load(ascalararr2.data());
782
783 amask = dvec > evec;
784 // check
785 for (size_t i = 0; i < vec_t::width; ++i)
786 {
787 BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]),
788 dval > ascalararr2[i]);
789 }
790 }
791}

◆ BOOST_AUTO_TEST_CASE() [13/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_io  )

Definition at line 879 of file TestSimdLibDouble.cpp.

880{
881 vec_t avec(3.14);
882 std::cout << avec << std::endl;
883}

◆ BOOST_AUTO_TEST_CASE() [14/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_load  )

Definition at line 179 of file TestSimdLibDouble.cpp.

180{
181 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
182 {}}; // double brace to deal with gcc 4.8.5 ...
183 vec_t avec;
184 avec.load(ascalararr.data());
185}

◆ BOOST_AUTO_TEST_CASE() [15/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_load_aligned  )

Definition at line 195 of file TestSimdLibDouble.cpp.

196{
197 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
198 {}}; // double brace to deal with gcc 4.8.5 ...
199 vec_t avec;
200 avec.load(ascalararr.data(), is_aligned);
201}
tinysimd::is_aligned
static constexpr struct tinysimd::is_aligned_t is_aligned

References tinysimd::is_aligned.

◆ BOOST_AUTO_TEST_CASE() [16/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_load_implicit  )

Definition at line 187 of file TestSimdLibDouble.cpp.

188{
189 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
190 {}}; // double brace to deal with gcc 4.8.5 ...
191 vec_t avec;
192 avec = *(reinterpret_cast<vec_t *>(ascalararr.data()));
193}

◆ BOOST_AUTO_TEST_CASE() [17/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_load_interleave_unload  )

Definition at line 831 of file TestSimdLibDouble.cpp.

832{
833 constexpr size_t nDof{5};
834 // no padding in load_interleave deinterleave_store
835 constexpr size_t nEle{vec_t::width * 5};
836 constexpr size_t nDofBlock = nDof * vec_t::width;
837
838 constexpr size_t size{nDof * nEle};
839 std::array<double, size> dofScalarArr{{}};
840 for (size_t i = 0; i < size; ++i)
841 {
842 dofScalarArr[i] = i;
843 }
844
845 // number of blocks
846 size_t nBlock = nEle / vec_t::width;
847
848 // aligned vector
849 std::vector<vec_t, allocator<vec_t>> dofVectorArr(nDof);
850
851 double *dataPtr = dofScalarArr.data();
852 // loop over blocks vec_t::width elements at the time
853 for (size_t b = 0; b < nBlock; ++b)
854 {
855 // load
856 load_interleave(dataPtr, nDof, dofVectorArr);
857
858 // manipulate each block
859 for (size_t j = 0; j < nDof; ++j)
860 {
861 dofVectorArr[j] = dofVectorArr[j] + j;
862 }
863
864 // store
865 deinterleave_store(dofVectorArr, nDof, dataPtr);
866 dataPtr += nDofBlock;
867 }
868
869 // check
870 for (size_t b = 0, i = 0; b < nBlock; ++b)
871 {
872 for (size_t j = 0; j < nDof; ++j, ++i)
873 {
874 BOOST_CHECK_EQUAL(dofScalarArr[i], i + j);
875 }
876 }
877}
tinysimd::load_interleave
void load_interleave(const T *in, size_t dataLen, std::vector< scalarT< T >, allocator< scalarT< T > > > &out)
Definition: scalar.hpp:309
tinysimd::deinterleave_store
void deinterleave_store(const std::vector< scalarT< T >, allocator< scalarT< T > > > &in, size_t dataLen, T *out)
Definition: scalar.hpp:319

References tinysimd::deinterleave_store(), and tinysimd::load_interleave().

◆ BOOST_AUTO_TEST_CASE() [18/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_load_unaligned  )

Definition at line 203 of file TestSimdLibDouble.cpp.

204{
205 std::array<double, vec_t::width> ascalararr{
206 {}}; // double brace to deal with gcc 4.8.5 ...
207 vec_t avec;
208 avec.load(ascalararr.data(), is_not_aligned);
209}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [19/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_log  )

Definition at line 698 of file TestSimdLibDouble.cpp.

699{
700 double val = 4.0;
701 vec_t avec(val);
702 vec_t alog = log(avec);
703 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
704 {}}; // double brace to deal with gcc 4.8.5 ...
705 alog.store(ascalararr.data());
706
707 for (size_t i = 0; i < vec_t::width; ++i)
708 {
709 BOOST_CHECK_EQUAL(ascalararr[i], std::log(val));
710 }
711}
tinysimd::log
scalarT< T > log(scalarT< T > in)
Definition: scalar.hpp:303

References tinysimd::log().

◆ BOOST_AUTO_TEST_CASE() [20/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_logic_and  )

Definition at line 793 of file TestSimdLibDouble.cpp.

794{
795 double aval = 4.0;
796 vec_t avec(aval);
797 using mask_t = simd<bool, vec_t::width>;
798 mask_t amask;
799
800 alignas(vec_t::alignment) std::array<std::uint64_t, vec_t::width>
801 ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
802 for (size_t i = 0; i < vec_t::width; ++i)
803 {
804 ascalararr[i] = mask_t::true_v;
805 }
806 amask.load(ascalararr.data());
807
808 // check
809 BOOST_CHECK_EQUAL(amask && false, false);
810 BOOST_CHECK_EQUAL(amask && true, true);
811
812 for (size_t i = 0; i < vec_t::width; ++i)
813 {
814 ascalararr[i] = mask_t::false_v;
815 }
816 amask.load(ascalararr.data());
817
818 // check
819 BOOST_CHECK_EQUAL(amask && false, false);
820 BOOST_CHECK_EQUAL(amask && true, false);
821
822 if (vec_t::width > 1)
823 {
824 ascalararr[0] = mask_t::true_v;
825 // check
826 BOOST_CHECK_EQUAL(amask && false, false);
827 BOOST_CHECK_EQUAL(amask && true, false);
828 }
829}

◆ BOOST_AUTO_TEST_CASE() [21/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_mem_size  )

Definition at line 151 of file TestSimdLibDouble.cpp.

152{
153 BOOST_CHECK_EQUAL(sizeof(vec_t), sizeof(double) * vec_t::width);
154}

◆ BOOST_AUTO_TEST_CASE() [22/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_mul_binary  )

Definition at line 596 of file TestSimdLibDouble.cpp.

597{
598 double val1 = -4.0;
599 double val2 = 2.5;
600 vec_t avec1(val1);
601 vec_t avec2(val2);
602 vec_t res = avec1 * avec2;
603 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
604 {}}; // double brace to deal with gcc 4.8.5 ...
605 res.store(ascalararr.data());
606
607 for (size_t i = 0; i < vec_t::width; ++i)
608 {
609 BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
610 }
611}

◆ BOOST_AUTO_TEST_CASE() [23/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_mul_unary  )

Definition at line 528 of file TestSimdLibDouble.cpp.

529{
530 double val1 = -4.0;
531 double val2 = 2.0;
532 vec_t res(val1);
533 vec_t avec(val2);
534 res *= avec;
535 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
536 {}}; // double brace to deal with gcc 4.8.5 ...
537 res.store(ascalararr.data());
538
539 for (size_t i = 0; i < vec_t::width; ++i)
540 {
541 BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
542 }
543}

◆ BOOST_AUTO_TEST_CASE() [24/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_scatter64  )

Definition at line 430 of file TestSimdLibDouble.cpp.

431{
432 vec_t avec;
433 using index_t = simd<size_t>;
434 index_t aindexvec;
435
436 // create and fill index
437 std::array<size_t, vec_t::width> aindex;
438 aindex[0] = 1;
439 if (vec_t::width > 1)
440 {
441 aindex[1] = 3;
442 }
443 if (vec_t::width > 2)
444 {
445 aindex[2] = 5;
446 aindex[3] = 6;
447 }
448 if (vec_t::width > 4)
449 {
450 aindex[4] = 8;
451 aindex[5] = 15;
452 aindex[6] = 20;
453 aindex[7] = 30;
454 }
455
456 // load index
457 aindexvec.load(aindex.data(), is_not_aligned);
458
459 // create scalar array
460 constexpr size_t scalarArraySize = 32;
461 std::array<double, scalarArraySize> ascalararr;
462
463 // fill vector
464 alignas(vec_t::alignment) std::array<double, vec_t::width> avecarr{{}};
465 avecarr[0] = 10;
466 if (vec_t::width > 1)
467 {
468 avecarr[1] = 9;
469 }
470
471 if (vec_t::width > 2)
472 {
473 avecarr[2] = 8;
474 avecarr[3] = 7;
475 }
476 if (vec_t::width > 4)
477 {
478 avecarr[4] = 4;
479 avecarr[5] = 3;
480 avecarr[6] = 2;
481 avecarr[7] = 1;
482 }
483 avec.load(avecarr.data());
484
485 avec.scatter(ascalararr.data(), aindexvec);
486
487 // check
488 for (size_t i = 0; i < vec_t::width; ++i)
489 {
490 BOOST_CHECK_EQUAL(avec[i], ascalararr[aindex[i]]);
491 }
492}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [25/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_sqrt  )

Definition at line 668 of file TestSimdLibDouble.cpp.

669{
670 double val = 4.0;
671 vec_t avec(val);
672 vec_t asqrt = sqrt(avec);
673 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
674 {}}; // double brace to deal with gcc 4.8.5 ...
675 asqrt.store(ascalararr.data());
676
677 for (size_t i = 0; i < vec_t::width; ++i)
678 {
679 BOOST_CHECK_EQUAL(ascalararr[i], std::sqrt(val));
680 }
681}
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:294

References tinysimd::sqrt().

◆ BOOST_AUTO_TEST_CASE() [26/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_store  )

Definition at line 259 of file TestSimdLibDouble.cpp.

260{
261 double val = 4.0;
262 vec_t avec(val);
263 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
264 {}}; // double brace to deal with gcc 4.8.5 ...
265 avec.store(ascalararr.data());
266
267 for (size_t i = 0; i < vec_t::width; ++i)
268 {
269 BOOST_CHECK_EQUAL(ascalararr[i], val);
270 }
271}

◆ BOOST_AUTO_TEST_CASE() [27/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_store_aligned  )

Definition at line 273 of file TestSimdLibDouble.cpp.

274{
275 double val = 4.0;
276 vec_t avec(val);
277 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
278 {}}; // double brace to deal with gcc 4.8.5 ...
279 avec.store(ascalararr.data(), is_aligned);
280
281 for (size_t i = 0; i < vec_t::width; ++i)
282 {
283 BOOST_CHECK_EQUAL(ascalararr[i], val);
284 }
285}

References tinysimd::is_aligned.

◆ BOOST_AUTO_TEST_CASE() [28/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_store_non_temporal  )

Definition at line 301 of file TestSimdLibDouble.cpp.

302{
303 double val = 4.0;
304 vec_t avec(val);
305 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
306 {}}; // double brace to deal with gcc 4.8.5 ...
307 avec.store(ascalararr.data(), is_not_reused);
308
309 for (size_t i = 0; i < vec_t::width; ++i)
310 {
311 BOOST_CHECK_EQUAL(ascalararr[i], val);
312 }
313}
tinysimd::is_not_reused
static constexpr struct tinysimd::is_not_reused_t is_not_reused

References tinysimd::is_not_reused.

◆ BOOST_AUTO_TEST_CASE() [29/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_store_unaligned  )

Definition at line 287 of file TestSimdLibDouble.cpp.

288{
289 double val = 4.0;
290 vec_t avec(val);
291 std::array<double, vec_t::width> ascalararr{
292 {}}; // double brace to deal with gcc 4.8.5 ...
293 avec.store(ascalararr.data(), is_not_aligned);
294
295 for (size_t i = 0; i < vec_t::width; ++i)
296 {
297 BOOST_CHECK_EQUAL(ascalararr[i], val);
298 }
299}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [30/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_sub_binary  )

Definition at line 579 of file TestSimdLibDouble.cpp.

580{
581 double val1 = -4.0;
582 double val2 = 2.5;
583 vec_t avec1(val1);
584 vec_t avec2(val2);
585 vec_t res = avec1 - avec2;
586 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
587 {}}; // double brace to deal with gcc 4.8.5 ...
588 res.store(ascalararr.data());
589
590 for (size_t i = 0; i < vec_t::width; ++i)
591 {
592 BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
593 }
594}

◆ BOOST_AUTO_TEST_CASE() [31/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_sub_unary  )

Definition at line 511 of file TestSimdLibDouble.cpp.

512{
513 double val1 = -4.0;
514 double val2 = 2.0;
515 vec_t res(val1);
516 vec_t avec(val2);
517 res -= avec;
518 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
519 {}}; // double brace to deal with gcc 4.8.5 ...
520 res.store(ascalararr.data());
521
522 for (size_t i = 0; i < vec_t::width; ++i)
523 {
524 BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
525 }
526}

◆ BOOST_AUTO_TEST_CASE() [32/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_subscript_assign_read  )

Definition at line 322 of file TestSimdLibDouble.cpp.

323{
324 vec_t avec;
325 alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
326 {}}; // double brace to deal with gcc 4.8.5 ...
327
328 for (size_t i = 0; i < vec_t::width; ++i)
329 {
330 ascalararr[i] = i;
331 }
332
333 for (size_t i = 0; i < vec_t::width; ++i)
334 {
335 avec[i] = ascalararr[i];
336 }
337
338 for (size_t i = 0; i < vec_t::width; ++i)
339 {
340 BOOST_CHECK_EQUAL(ascalararr[i], avec[i]);
341 }
342}

◆ BOOST_AUTO_TEST_CASE() [33/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_type_traits  )

Definition at line 128 of file TestSimdLibDouble.cpp.

129{
130 {
131 using namespace details;
132
133 BOOST_CHECK_EQUAL(has_width<double>::value, false);
134 BOOST_CHECK_EQUAL(has_width<vec_t>::value, true);
135
136 BOOST_CHECK_EQUAL(has_alignment<double>::value, false);
137 BOOST_CHECK_EQUAL(has_alignment<vec_t>::value, true);
138
139 BOOST_CHECK_EQUAL(has_scalarType<double>::value, false);
140 BOOST_CHECK_EQUAL(has_scalarType<vec_t>::value, true);
141 }
142
143 BOOST_CHECK_EQUAL(is_vector<double>::value, false);
144 BOOST_CHECK_EQUAL(is_vector<vec_t>::value, true);
145
146 BOOST_CHECK_EQUAL(is_vector_floating_point<double>::value, false);
147 BOOST_CHECK_EQUAL(is_vector_floating_point<simd<int>>::value, false);
148 BOOST_CHECK_EQUAL(is_vector_floating_point<vec_t>::value, true);
149}
tinysimd::is_vector_floating_point
Definition: traits.hpp:150
tinysimd::is_vector
Definition: traits.hpp:140

◆ BOOST_AUTO_TEST_CASE() [34/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibDouble_width_alignment  )

Definition at line 90 of file TestSimdLibDouble.cpp.

91{
92 std::size_t width, alignment;
93
94#if defined(USING_SCALAR)
95 std::cout << "scalar double" << std::endl;
96#endif
97#if defined(USING_AVX2)
98 std::cout << "avx2 double" << std::endl;
99#endif
100#if defined(USING_AVX512)
101 std::cout << "avx512 double" << std::endl;
102#endif
103#if defined(USING_SVE)
104 std::cout << "sve double" << std::endl;
105#endif
106
107 // double
108 width = simd<double>::width;
109 alignment = simd<double>::alignment;
110 BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
111 BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
112 // std::int32_t index forcing # of lanes
113 width = simd<std::int32_t, vec_t::width>::width;
114 alignment = simd<std::int32_t, vec_t::width>::alignment;
115 BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
116 // std::int64_t index forcing # of lanes
117 width = simd<std::int64_t, vec_t::width>::width;
118 alignment = simd<std::int64_t, vec_t::width>::alignment;
119 BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
120 BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
121 // std::int64_t default index
122 width = simd<std::int64_t>::width;
123 alignment = simd<std::int64_t>::alignment;
124 BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
125 BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
126}
ALIGNMENT
#define ALIGNMENT
Definition: TestSimdLibDouble.cpp:48
NUM_LANES_64BITS
#define NUM_LANES_64BITS
The above copyright notice and this permission notice shall be included.
Definition: TestSimdLibDouble.cpp:47

References ALIGNMENT, and NUM_LANES_64BITS.

◆ BOOST_AUTO_TEST_CASE() [35/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_abs  )

Definition at line 609 of file TestSimdLibSingle.cpp.

610{
611 float val = -4.0;
612 vec_t avec(val);
613 vec_t aabs = abs(avec);
614 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
615 {}}; // float brace to deal with gcc 4.8.5 ...
616 aabs.store(ascalararr.data());
617
618 for (size_t i = 0; i < vec_t::width; ++i)
619 {
620 BOOST_CHECK_EQUAL(ascalararr[i], std::abs(val));
621 }
622}

References tinysimd::abs().

◆ BOOST_AUTO_TEST_CASE() [36/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_add_binary  )

Definition at line 488 of file TestSimdLibSingle.cpp.

489{
490 float val1 = -4.0;
491 float val2 = 2.5;
492 vec_t avec1(val1);
493 vec_t avec2(val2);
494 vec_t res = avec1 + avec2;
495 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
496 {}}; // double brace to deal with gcc 4.8.5 ...
497 res.store(ascalararr.data());
498
499 for (size_t i = 0; i < vec_t::width; ++i)
500 {
501 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
502 }
503}

◆ BOOST_AUTO_TEST_CASE() [37/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_add_mul  )

Definition at line 556 of file TestSimdLibSingle.cpp.

557{
558 float val1 = -4.0;
559 float val2 = 2.0;
560 float val3 = 2.0;
561 vec_t avec1(val1);
562 vec_t avec2(val2);
563 vec_t avec3(val3);
564 vec_t res = avec1 + avec2 * avec3;
565 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
566 {}}; // float brace to deal with gcc 4.8.5 ...
567 res.store(ascalararr.data());
568
569 for (size_t i = 0; i < vec_t::width; ++i)
570 {
571 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 + val3);
572 }
573}

◆ BOOST_AUTO_TEST_CASE() [38/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_add_unary  )

Definition at line 420 of file TestSimdLibSingle.cpp.

421{
422 float val1 = -4.0;
423 float val2 = 2.0;
424 vec_t res(val1);
425 vec_t avec(val2);
426 res += avec;
427 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
428 {}}; // float brace to deal with gcc 4.8.5 ...
429 res.store(ascalararr.data());
430
431 for (size_t i = 0; i < vec_t::width; ++i)
432 {
433 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
434 }
435}

◆ BOOST_AUTO_TEST_CASE() [39/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_ctors  )

Definition at line 149 of file TestSimdLibSingle.cpp.

150{
151 vec_t avec1;
152
153 vec_t::scalarType ascalar = 0;
154 vec_t avec2(ascalar);
155 vec_t avec3{ascalar};
156 vec_t avec4 = ascalar;
157
158 vec_t avec5(avec2);
159 vec_t avec6{avec4};
160
161 vec_t avec7(avec2._data);
162 vec_t avec8{avec2._data};
163
164 vec_t::vectorType anative;
165 vec_t avec9(anative);
166 vec_t avec10{anative};
167
168 boost::ignore_unused(avec1, avec3, avec5, avec6, avec7, avec8, avec9,
169 avec10);
170}
Nektar::Collections::vec_t
simd< NekDouble > vec_t
Definition: CoalescedGeomData.h:49

◆ BOOST_AUTO_TEST_CASE() [40/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_div_binary  )

Definition at line 539 of file TestSimdLibSingle.cpp.

540{
541 float val1 = -4.0;
542 float val2 = 2.5;
543 vec_t avec1(val1);
544 vec_t avec2(val2);
545 vec_t res = avec1 / avec2;
546 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
547 {}}; // double brace to deal with gcc 4.8.5 ...
548 res.store(ascalararr.data());
549
550 for (size_t i = 0; i < vec_t::width; ++i)
551 {
552 BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
553 }
554}

◆ BOOST_AUTO_TEST_CASE() [41/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_div_unary  )

Definition at line 471 of file TestSimdLibSingle.cpp.

472{
473 float val1 = -4.0;
474 float val2 = 2.0;
475 vec_t res(val1);
476 vec_t avec(val2);
477 res /= avec;
478 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
479 {}}; // float brace to deal with gcc 4.8.5 ...
480 res.store(ascalararr.data());
481
482 for (size_t i = 0; i < vec_t::width; ++i)
483 {
484 BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
485 }
486}

◆ BOOST_AUTO_TEST_CASE() [42/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_fused_add_mul  )

Definition at line 575 of file TestSimdLibSingle.cpp.

576{
577 float val1 = -4.0;
578 float val2 = 1.5;
579 float val3 = 5.0;
580 vec_t avec1(val1);
581 vec_t avec2(val2);
582 vec_t avec3(val3);
583 avec1.fma(avec2, avec3);
584 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
585 {}}; // double brace to deal with gcc 4.8.5 ...
586 avec1.store(ascalararr.data());
587
588 for (size_t i = 0; i < vec_t::width; ++i)
589 {
590 BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 * val3);
591 }
592}

◆ BOOST_AUTO_TEST_CASE() [43/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_gather32  )

Definition at line 291 of file TestSimdLibSingle.cpp.

292{
293 vec_t avec;
294 using index_t = simd<std::uint32_t>;
295 index_t aindexvec;
296
297 // create and fill index
298 std::array<std::uint32_t, vec_t::width> aindex;
299 aindex[0] = 0;
300 if (vec_t::width > 2)
301 {
302 aindex[1] = 3;
303 aindex[2] = 5;
304 aindex[3] = 6;
305 }
306 if (vec_t::width > 4)
307 {
308 aindex[4] = 8;
309 aindex[5] = 15;
310 aindex[6] = 20;
311 aindex[7] = 23;
312 }
313 if (vec_t::width > 8)
314 {
315 aindex[8] = 24;
316 aindex[9] = 28;
317 aindex[10] = 33;
318 aindex[11] = 40;
319 aindex[12] = 41;
320 aindex[13] = 45;
321 aindex[14] = 60;
322 aindex[15] = 61;
323 }
324
325 // load index
326 aindexvec.load(aindex.data(), is_not_aligned);
327
328 // create and fill scalar array
329 constexpr size_t scalarArraySize = 64;
330 std::array<float, scalarArraySize> ascalararr;
331 for (size_t i = 0; i < scalarArraySize; ++i)
332 {
333 ascalararr[i] = i;
334 }
335
336 avec.gather(ascalararr.data(), aindexvec);
337
338 // check
339 for (size_t i = 0; i < vec_t::width; ++i)
340 {
341 BOOST_CHECK_EQUAL(ascalararr[aindex[i]], avec[i]);
342 }
343}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [44/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_greater  )

Definition at line 639 of file TestSimdLibSingle.cpp.

640{
641 float aval = 4.0;
642 vec_t avec(aval);
643 using mask_t = simd<bool, vec_t::width>;
644 mask_t amask;
645
646 amask = avec > avec;
647 // check
648 alignas(vec_t::alignment) std::array<std::uint32_t, vec_t::width>
649 ascalararr{{}}; // float brace to deal with gcc 4.8.5 ...
650 amask.store(ascalararr.data());
651 for (size_t i = 0; i < vec_t::width; ++i)
652 {
653 // type conversion make lvalue in rvalue, needed pre-c++17
654 BOOST_CHECK_EQUAL(ascalararr[i], (std::uint32_t)mask_t::false_v);
655 }
656
657 float bval = 3.0;
658 vec_t bvec(bval);
659
660 amask = avec > bvec;
661 // check
662 amask.store(ascalararr.data());
663 for (size_t i = 0; i < vec_t::width; ++i)
664 {
665 // type conversion make lvalue in rvalue, needed pre-c++17
666 BOOST_CHECK_EQUAL(ascalararr[i], (std::uint32_t)mask_t::true_v);
667 }
668
669 float cval = 5.0;
670 vec_t cvec(cval);
671
672 amask = avec > cvec;
673 // check
674 amask.store(ascalararr.data());
675 for (size_t i = 0; i < vec_t::width; ++i)
676 {
677 // type conversion make lvalue in rvalue, needed pre-c++17
678 BOOST_CHECK_EQUAL(ascalararr[i], (std::uint32_t)mask_t::false_v);
679 }
680
681 if (vec_t::width == 4)
682 {
683 alignas(vec_t::alignment) std::array<float, 4> ascalararr2{
684 {1.0, 2.0, 3.0, 4.0}}; // float brace to deal with gcc 4.8.5 ...
685 float dval = 2.0;
686 vec_t dvec(dval);
687 vec_t evec;
688 evec.load(ascalararr2.data());
689
690 amask = dvec > evec;
691 // check
692 for (size_t i = 0; i < vec_t::width; ++i)
693 {
694 BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]), dvec[i] > evec[i]);
695 }
696 }
697
698 if (vec_t::width == 8)
699 {
700 alignas(vec_t::alignment) std::array<float, 8> ascalararr2{
701 {1.0, 2.0, 3.0, 4.0, 3.0, 2.0,
702 1.0}}; // double brace to deal with gcc 4.8.5 ...
703 float dval = 2.0;
704 vec_t dvec(dval);
705 vec_t evec;
706 evec.load(ascalararr2.data());
707
708 amask = dvec > evec;
709 // check
710 for (size_t i = 0; i < vec_t::width; ++i)
711 {
712 BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]),
713 dval > ascalararr2[i]);
714 }
715 }
716}

◆ BOOST_AUTO_TEST_CASE() [45/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_io  )

Definition at line 804 of file TestSimdLibSingle.cpp.

805{
806 vec_t avec(3.14);
807 std::cout << avec << std::endl;
808}

◆ BOOST_AUTO_TEST_CASE() [46/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_load  )

Definition at line 172 of file TestSimdLibSingle.cpp.

173{
174 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
175 {}}; // double brace to deal with gcc 4.8.5 ...
176 vec_t avec;
177 avec.load(ascalararr.data());
178}

◆ BOOST_AUTO_TEST_CASE() [47/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_load_aligned  )

Definition at line 188 of file TestSimdLibSingle.cpp.

189{
190 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
191 {}}; // double brace to deal with gcc 4.8.5 ...
192 vec_t avec;
193 avec.load(ascalararr.data(), is_aligned);
194}

References tinysimd::is_aligned.

◆ BOOST_AUTO_TEST_CASE() [48/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_load_implicit  )

Definition at line 180 of file TestSimdLibSingle.cpp.

181{
182 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
183 {}}; // double brace to deal with gcc 4.8.5 ...
184 vec_t avec;
185 avec = *(reinterpret_cast<vec_t *>(ascalararr.data()));
186}

◆ BOOST_AUTO_TEST_CASE() [49/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_load_interleave_unload  )

Definition at line 756 of file TestSimdLibSingle.cpp.

757{
758 constexpr size_t nDof{5};
759 // no padding in load_interleave deinterleave_store
760 constexpr size_t nEle{vec_t::width * 5};
761 constexpr size_t nDofBlock = nDof * vec_t::width;
762
763 constexpr size_t size{nDof * nEle};
764 std::array<float, size> dofScalarArr{{}};
765 for (size_t i = 0; i < size; ++i)
766 {
767 dofScalarArr[i] = i;
768 }
769
770 // number of blocks
771 size_t nBlock = nEle / vec_t::width;
772
773 // aligned vector
774 std::vector<vec_t, allocator<vec_t>> dofVectorArr(nDof);
775
776 float *dataPtr = dofScalarArr.data();
777 // loop over blocks vec_t::width elements at the time
778 for (size_t b = 0; b < nBlock; ++b)
779 {
780 // load
781 load_interleave(dataPtr, nDof, dofVectorArr);
782
783 // manipulate each block
784 for (size_t j = 0; j < nDof; ++j)
785 {
786 dofVectorArr[j] = dofVectorArr[j] + j;
787 }
788
789 // store
790 deinterleave_store(dofVectorArr, nDof, dataPtr);
791 dataPtr += nDofBlock;
792 }
793
794 // check
795 for (size_t b = 0, i = 0; b < nBlock; ++b)
796 {
797 for (size_t j = 0; j < nDof; ++j, ++i)
798 {
799 BOOST_CHECK_EQUAL(dofScalarArr[i], i + j);
800 }
801 }
802}

References tinysimd::deinterleave_store(), and tinysimd::load_interleave().

◆ BOOST_AUTO_TEST_CASE() [50/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_load_unaligned  )

Definition at line 196 of file TestSimdLibSingle.cpp.

197{
198 std::array<float, vec_t::width> ascalararr{
199 {}}; // double brace to deal with gcc 4.8.5 ...
200 vec_t avec;
201 avec.load(ascalararr.data(), is_not_aligned);
202}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [51/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_log  )

Definition at line 624 of file TestSimdLibSingle.cpp.

625{
626 float val = 4.0;
627 vec_t avec(val);
628 vec_t alog = log(avec);
629 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
630 {}}; // float brace to deal with gcc 4.8.5 ...
631 alog.store(ascalararr.data());
632
633 for (size_t i = 0; i < vec_t::width; ++i)
634 {
635 BOOST_CHECK_EQUAL(ascalararr[i], std::log(val));
636 }
637}

References tinysimd::log().

◆ BOOST_AUTO_TEST_CASE() [52/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_logic_and  )

Definition at line 718 of file TestSimdLibSingle.cpp.

719{
720 float aval = 4.0;
721 vec_t avec(aval);
722 using mask_t = simd<bool, vec_t::width>;
723 mask_t amask;
724
725 alignas(vec_t::alignment) std::array<std::uint32_t, vec_t::width>
726 ascalararr{{}}; // float brace to deal with gcc 4.8.5 ...
727 for (size_t i = 0; i < vec_t::width; ++i)
728 {
729 ascalararr[i] = mask_t::true_v;
730 }
731 amask.load(ascalararr.data());
732
733 // check
734 BOOST_CHECK_EQUAL(amask && false, false);
735 BOOST_CHECK_EQUAL(amask && true, true);
736
737 for (size_t i = 0; i < vec_t::width; ++i)
738 {
739 ascalararr[i] = mask_t::false_v;
740 }
741 amask.load(ascalararr.data());
742
743 // check
744 BOOST_CHECK_EQUAL(amask && false, false);
745 BOOST_CHECK_EQUAL(amask && true, false);
746
747 if (vec_t::width > 1)
748 {
749 ascalararr[0] = mask_t::true_v;
750 // check
751 BOOST_CHECK_EQUAL(amask && false, false);
752 BOOST_CHECK_EQUAL(amask && true, false);
753 }
754}

◆ BOOST_AUTO_TEST_CASE() [53/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_mem_size  )

Definition at line 144 of file TestSimdLibSingle.cpp.

145{
146 BOOST_CHECK_EQUAL(sizeof(vec_t), sizeof(float) * vec_t::width);
147}

◆ BOOST_AUTO_TEST_CASE() [54/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_mul_binary  )

Definition at line 522 of file TestSimdLibSingle.cpp.

523{
524 float val1 = -4.0;
525 float val2 = 2.5;
526 vec_t avec1(val1);
527 vec_t avec2(val2);
528 vec_t res = avec1 * avec2;
529 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
530 {}}; // double brace to deal with gcc 4.8.5 ...
531 res.store(ascalararr.data());
532
533 for (size_t i = 0; i < vec_t::width; ++i)
534 {
535 BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
536 }
537}

◆ BOOST_AUTO_TEST_CASE() [55/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_mul_unary  )

Definition at line 454 of file TestSimdLibSingle.cpp.

455{
456 float val1 = -4.0;
457 float val2 = 2.0;
458 vec_t res(val1);
459 vec_t avec(val2);
460 res *= avec;
461 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
462 {}}; // float brace to deal with gcc 4.8.5 ...
463 res.store(ascalararr.data());
464
465 for (size_t i = 0; i < vec_t::width; ++i)
466 {
467 BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
468 }
469}

◆ BOOST_AUTO_TEST_CASE() [56/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_scatter32  )

Definition at line 345 of file TestSimdLibSingle.cpp.

346{
347 vec_t avec;
348 using index_t = simd<std::uint32_t>;
349 index_t aindexvec;
350
351 // create and fill index
352 std::array<std::uint32_t, vec_t::width> aindex;
353 aindex[0] = 1;
354 if (vec_t::width > 1)
355 {
356 aindex[1] = 3;
357 }
358 if (vec_t::width > 2)
359 {
360 aindex[2] = 5;
361 aindex[3] = 6;
362 }
363 if (vec_t::width > 4)
364 {
365 aindex[4] = 8;
366 aindex[5] = 15;
367 aindex[6] = 20;
368 aindex[7] = 30;
369 }
370 if (vec_t::width > 8)
371 {
372 aindex[8] = 31;
373 aindex[9] = 32;
374 aindex[10] = 35;
375 aindex[11] = 40;
376 aindex[12] = 41;
377 aindex[13] = 45;
378 aindex[14] = 60;
379 aindex[15] = 61;
380 }
381
382 // load index
383 aindexvec.load(aindex.data(), is_not_aligned);
384
385 // create scalar array
386 constexpr size_t scalarArraySize = 64;
387 std::array<float, scalarArraySize> ascalararr;
388
389 // fill vector
390 alignas(vec_t::alignment) std::array<float, vec_t::width> avecarr{{}};
391 avecarr[0] = 10;
392 if (vec_t::width > 1)
393 {
394 avecarr[1] = 9;
395 }
396
397 if (vec_t::width > 2)
398 {
399 avec[2] = 8;
400 avec[3] = 7;
401 }
402 if (vec_t::width > 4)
403 {
404 avec[4] = 4;
405 avec[5] = 3;
406 avec[6] = 2;
407 avec[7] = 1;
408 }
409 avec.load(avecarr.data());
410
411 avec.scatter(ascalararr.data(), aindexvec);
412
413 // check
414 for (size_t i = 0; i < vec_t::width; ++i)
415 {
416 BOOST_CHECK_EQUAL(avec[i], ascalararr[aindex[i]]);
417 }
418}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [57/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_sqrt  )

Definition at line 594 of file TestSimdLibSingle.cpp.

595{
596 float val = 4.0;
597 vec_t avec(val);
598 vec_t asqrt = sqrt(avec);
599 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
600 {}}; // float brace to deal with gcc 4.8.5 ...
601 asqrt.store(ascalararr.data());
602
603 for (size_t i = 0; i < vec_t::width; ++i)
604 {
605 BOOST_CHECK_EQUAL(ascalararr[i], std::sqrt(val));
606 }
607}

References tinysimd::sqrt().

◆ BOOST_AUTO_TEST_CASE() [58/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_store  )

Definition at line 204 of file TestSimdLibSingle.cpp.

205{
206 float val = 4.0;
207 vec_t avec(val);
208 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
209 {}}; // float brace to deal with gcc 4.8.5 ...
210 avec.store(ascalararr.data());
211
212 for (size_t i = 0; i < vec_t::width; ++i)
213 {
214 BOOST_CHECK_EQUAL(ascalararr[i], val);
215 }
216}

◆ BOOST_AUTO_TEST_CASE() [59/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_store_aligned  )

Definition at line 218 of file TestSimdLibSingle.cpp.

219{
220 float val = 4.0;
221 vec_t avec(val);
222 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
223 {}}; // float brace to deal with gcc 4.8.5 ...
224 avec.store(ascalararr.data(), is_aligned);
225
226 for (size_t i = 0; i < vec_t::width; ++i)
227 {
228 BOOST_CHECK_EQUAL(ascalararr[i], val);
229 }
230}

References tinysimd::is_aligned.

◆ BOOST_AUTO_TEST_CASE() [60/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_store_non_temporal  )

Definition at line 246 of file TestSimdLibSingle.cpp.

247{
248 float val = 4.0;
249 vec_t avec(val);
250 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
251 {}}; // float brace to deal with gcc 4.8.5 ...
252 avec.store(ascalararr.data(), is_not_reused);
253
254 for (size_t i = 0; i < vec_t::width; ++i)
255 {
256 BOOST_CHECK_EQUAL(ascalararr[i], val);
257 }
258}

References tinysimd::is_not_reused.

◆ BOOST_AUTO_TEST_CASE() [61/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_store_unaligned  )

Definition at line 232 of file TestSimdLibSingle.cpp.

233{
234 float val = 4.0;
235 vec_t avec(val);
236 std::array<float, vec_t::width> ascalararr{
237 {}}; // float brace to deal with gcc 4.8.5 ...
238 avec.store(ascalararr.data(), is_not_aligned);
239
240 for (size_t i = 0; i < vec_t::width; ++i)
241 {
242 BOOST_CHECK_EQUAL(ascalararr[i], val);
243 }
244}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [62/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_sub_binary  )

Definition at line 505 of file TestSimdLibSingle.cpp.

506{
507 float val1 = -4.0;
508 float val2 = 2.5;
509 vec_t avec1(val1);
510 vec_t avec2(val2);
511 vec_t res = avec1 - avec2;
512 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
513 {}}; // double brace to deal with gcc 4.8.5 ...
514 res.store(ascalararr.data());
515
516 for (size_t i = 0; i < vec_t::width; ++i)
517 {
518 BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
519 }
520}

◆ BOOST_AUTO_TEST_CASE() [63/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_sub_unary  )

Definition at line 437 of file TestSimdLibSingle.cpp.

438{
439 float val1 = -4.0;
440 float val2 = 2.0;
441 vec_t res(val1);
442 vec_t avec(val2);
443 res -= avec;
444 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
445 {}}; // float brace to deal with gcc 4.8.5 ...
446 res.store(ascalararr.data());
447
448 for (size_t i = 0; i < vec_t::width; ++i)
449 {
450 BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
451 }
452}

◆ BOOST_AUTO_TEST_CASE() [64/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibFloat_type_traits  )

Definition at line 123 of file TestSimdLibSingle.cpp.

124{
125 using namespace details;
126
127 BOOST_CHECK_EQUAL(has_width<float>::value, false);
128 BOOST_CHECK_EQUAL(has_width<vec_t>::value, true);
129
130 BOOST_CHECK_EQUAL(has_alignment<float>::value, false);
131 BOOST_CHECK_EQUAL(has_alignment<vec_t>::value, true);
132
133 BOOST_CHECK_EQUAL(has_scalarType<float>::value, false);
134 BOOST_CHECK_EQUAL(has_scalarType<vec_t>::value, true);
135
136 BOOST_CHECK_EQUAL(is_vector<float>::value, false);
137 BOOST_CHECK_EQUAL(is_vector<vec_t>::value, true);
138
139 BOOST_CHECK_EQUAL(is_vector_floating_point<float>::value, false);
140 BOOST_CHECK_EQUAL(is_vector_floating_point<simd<int>>::value, false);
141 BOOST_CHECK_EQUAL(is_vector_floating_point<vec_t>::value, true);
142}

◆ BOOST_AUTO_TEST_CASE() [65/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibInt32_load  )

Definition at line 235 of file TestSimdLibDouble.cpp.

236{
237 alignas(vec_t::alignment) std::array<std::uint32_t, vec_t::width>
238 ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
239 simd<std::uint32_t, vec_t::width> aindex;
240 aindex.load(ascalararr.data());
241}

◆ BOOST_AUTO_TEST_CASE() [66/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibInt32_load_aligned  )

Definition at line 243 of file TestSimdLibDouble.cpp.

244{
245 alignas(vec_t::alignment) std::array<std::uint32_t, vec_t::width>
246 ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
247 simd<std::uint32_t, vec_t::width> aindex;
248 aindex.load(ascalararr.data(), is_aligned);
249}

References tinysimd::is_aligned.

◆ BOOST_AUTO_TEST_CASE() [67/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibInt32_load_unaligned  )

Definition at line 251 of file TestSimdLibDouble.cpp.

252{
253 std::array<std::uint32_t, vec_t::width> ascalararr{
254 {}}; // double brace to deal with gcc 4.8.5 ...
255 simd<std::uint32_t, vec_t::width> aindex;
256 aindex.load(ascalararr.data(), is_not_aligned);
257}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [68/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibInt64_load  )

Definition at line 211 of file TestSimdLibDouble.cpp.

212{
213 alignas(vec_t::alignment) std::array<std::uint64_t, vec_t::width>
214 ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
215 simd<std::uint64_t, vec_t::width> aindex;
216 aindex.load(ascalararr.data());
217}

◆ BOOST_AUTO_TEST_CASE() [69/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibInt64_load_aligned  )

Definition at line 219 of file TestSimdLibDouble.cpp.

220{
221 alignas(vec_t::alignment) std::array<std::uint64_t, vec_t::width>
222 ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
223 simd<std::uint64_t, vec_t::width> aindex;
224 aindex.load(ascalararr.data(), is_aligned);
225}

References tinysimd::is_aligned.

◆ BOOST_AUTO_TEST_CASE() [70/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibInt64_load_unaligned  )

Definition at line 227 of file TestSimdLibDouble.cpp.

228{
229 std::array<std::uint64_t, vec_t::width> ascalararr{
230 {}}; // double brace to deal with gcc 4.8.5 ...
231 simd<std::uint64_t, vec_t::width> aindex;
232 aindex.load(ascalararr.data(), is_not_aligned);
233}

References tinysimd::is_not_aligned.

◆ BOOST_AUTO_TEST_CASE() [71/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibSingle_broadcast  )

Definition at line 260 of file TestSimdLibSingle.cpp.

261{
262 // explictly float literal for
263 // Visual Studio 14 2015 Win64 compiler bug
264 vec_t::scalarType ascalar{3.333f};
265 vec_t avec;
266 avec.broadcast(ascalar);
267}

◆ BOOST_AUTO_TEST_CASE() [72/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibSingle_subscript_assign_read  )

Definition at line 269 of file TestSimdLibSingle.cpp.

270{
271 vec_t avec;
272 alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
273 {}}; // double brace to deal with gcc 4.8.5 ...
274
275 for (size_t i = 0; i < vec_t::width; ++i)
276 {
277 ascalararr[i] = i;
278 }
279
280 for (size_t i = 0; i < vec_t::width; ++i)
281 {
282 avec[i] = ascalararr[i];
283 }
284
285 for (size_t i = 0; i < vec_t::width; ++i)
286 {
287 BOOST_CHECK_EQUAL(ascalararr[i], avec[i]);
288 }
289}

◆ BOOST_AUTO_TEST_CASE() [73/73]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE ( SimdLibSingle_width_alignment  )

Definition at line 89 of file TestSimdLibSingle.cpp.

90{
91 std::size_t width, alignment;
92
93#if defined(USING_SCALAR)
94 std::cout << "scalar float" << std::endl;
95#endif
96#if defined(USING_AVX2)
97 std::cout << "avx2 float" << std::endl;
98#endif
99#if defined(USING_AVX512)
100 std::cout << "avx512 float" << std::endl;
101#endif
102#if defined(USING_SVE)
103 std::cout << "sve float" << std::endl;
104#endif
105
106 // float
107 width = simd<float>::width;
108 alignment = simd<float>::alignment;
109 BOOST_CHECK_EQUAL(width, NUM_LANES_32BITS);
110 BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
111 // std::int32_t index forcing # of lanes
112 width = simd<std::int32_t, vec_t::width>::width;
113 alignment = simd<std::int32_t, vec_t::width>::alignment;
114 BOOST_CHECK_EQUAL(width, NUM_LANES_32BITS);
115 BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
116 // std::int32_t default index
117 width = simd<std::int32_t>::width;
118 alignment = simd<std::int32_t>::alignment;
119 BOOST_CHECK_EQUAL(width, NUM_LANES_32BITS);
120 BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
121}
NUM_LANES_32BITS
#define NUM_LANES_32BITS
The above copyright notice and this permission notice shall be included.
Definition: TestSimdLibSingle.cpp:46
ALIGNMENT
#define ALIGNMENT
Definition: TestSimdLibSingle.cpp:47

References ALIGNMENT, and NUM_LANES_32BITS.

Generated on Wed Jan 31 2024 08:26:58 for Nektar++ by doxygen 1.9.4