Nektar::SimdLibTests Namespace Reference

Typedefs
using	vec_t = simd< double >
using	default_long_vec_t = longsimd< double >
using	long_vec_t = longsimd< double, 3 *vec_t::width >

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_longsimd_width)
	BOOST_AUTO_TEST_CASE (SimdLibDouble_longsimd_mixed_arithmetic)
	BOOST_AUTO_TEST_CASE (SimdLibDouble_longsimd_interleave_helpers)
	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_longsimd_mixed_arithmetic)
	BOOST_AUTO_TEST_CASE (SimdLibFloat_longsimd_interleave_helpers)
	BOOST_AUTO_TEST_CASE (SimdLibFloat_io)

Typedef Documentation

default_long_vec_t

using Nektar::SimdLibTests::default_long_vec_t = typedef longsimd<double>

Definition at line 86 of file TestSimdLibDouble.cpp.

long_vec_t

typedef longsimd< float, 3 *vec_t::width > Nektar::SimdLibTests::long_vec_t

Definition at line 87 of file TestSimdLibDouble.cpp.

vec_t

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

Definition at line 85 of file TestSimdLibDouble.cpp.

Function Documentation

BOOST_AUTO_TEST_CASE() [1/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_abs

)

Definition at line 682 of file TestSimdLibDouble.cpp.

{
    double val = -4.0;
    vec_t avec(val);
    vec_t aabs = abs(avec);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    aabs.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], std::abs(val));
    }
}

References tinysimd::abs().

BOOST_AUTO_TEST_CASE() [2/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_add_binary

)

Definition at line 561 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 + avec2;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
    }
}

BOOST_AUTO_TEST_CASE() [3/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_add_mul

)

Definition at line 629 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 1.5;
    double val3 = 5.0;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t avec3(val3);
    vec_t res = avec1 + avec2 * avec3;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 * val3);
    }
}

BOOST_AUTO_TEST_CASE() [4/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_add_unary

)

Definition at line 493 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res += avec;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
    }
}

BOOST_AUTO_TEST_CASE() [5/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_broadcast

)

Definition at line 314 of file TestSimdLibDouble.cpp.

{
    vec_t::scalarType ascalar{3.333};
    vec_t avec;
    avec.broadcast(ascalar);
}

BOOST_AUTO_TEST_CASE() [6/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_ctors

)

Definition at line 158 of file TestSimdLibDouble.cpp.

{
    [[maybe_unused]] vec_t avec1;
 
    vec_t::scalarType ascalar = 0;
    vec_t avec2(ascalar);
    [[maybe_unused]] vec_t avec3{ascalar};
    vec_t avec4 = ascalar;
 
    [[maybe_unused]] vec_t avec5(avec2);
    [[maybe_unused]] vec_t avec6{avec4};
 
    [[maybe_unused]] vec_t avec7(avec2._data);
    [[maybe_unused]] vec_t avec8{avec2._data};
 
    vec_t::vectorType anative;
    [[maybe_unused]] vec_t avec9(anative);
    [[maybe_unused]] vec_t avec10{anative};
}

BOOST_AUTO_TEST_CASE() [7/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_div_binary

)

Definition at line 612 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 / avec2;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
    }
}

BOOST_AUTO_TEST_CASE() [8/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_div_unary

)

Definition at line 544 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res /= avec;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
    }
}

BOOST_AUTO_TEST_CASE() [9/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_fused_add_mul

)

Definition at line 648 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 1.5;
    double val3 = 5.0;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t avec3(val3);
    avec1.fma(avec2, avec3);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    avec1.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 * val3);
    }
}

BOOST_AUTO_TEST_CASE() [10/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_gather32

)

Definition at line 386 of file TestSimdLibDouble.cpp.

{
    vec_t avec;
    using index_t = simd<std::uint32_t, vec_t::width>;
    index_t aindexvec;
 
    // create and fill index
    std::array<std::uint32_t, vec_t::width> aindex;
    aindex[0] = 0;
    if (vec_t::width > 2)
    {
        aindex[1] = 3;
        aindex[2] = 5;
        aindex[3] = 6;
    }
    if (vec_t::width > 4)
    {
        aindex[4] = 8;
        aindex[5] = 15;
        aindex[6] = 16;
        aindex[7] = 20;
    }
 
    // load index
    aindexvec.load(aindex.data(), is_not_aligned);
 
    // create and fill scalar array
    constexpr size_t scalarArraySize = 32;
    std::array<double, scalarArraySize> ascalararr;
    for (size_t i = 0; i < scalarArraySize; ++i)
    {
        ascalararr[i] = i;
    }
 
    avec.gather(ascalararr.data(), aindexvec);
 
    // check
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[aindex[i]], avec[i]);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [11/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_gather64

)

Definition at line 343 of file TestSimdLibDouble.cpp.

{
    vec_t avec;
    using index_t = simd<size_t>;
    index_t aindexvec;
 
    // create and fill index
    std::array<size_t, vec_t::width> aindex;
    aindex[0] = 0;
    if (vec_t::width > 2)
    {
        aindex[1] = 3;
        aindex[2] = 5;
        aindex[3] = 6;
    }
    if (vec_t::width > 4)
    {
        aindex[4] = 8;
        aindex[5] = 15;
        aindex[6] = 16;
        aindex[7] = 20;
    }
 
    // load index
    aindexvec.load(aindex.data(), is_not_aligned);
 
    // create and fill scalar array
    constexpr size_t scalarArraySize = 32;
    std::array<double, scalarArraySize> ascalararr;
    for (size_t i = 0; i < scalarArraySize; ++i)
    {
        ascalararr[i] = i;
    }
 
    avec.gather(ascalararr.data(), aindexvec);
 
    // check
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[aindex[i]], avec[i]);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [12/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_greater

)

Definition at line 712 of file TestSimdLibDouble.cpp.

{
    double aval = 4.0;
    vec_t avec(aval);
    using mask_t = simd<bool, vec_t::width>;
    mask_t amask;
 
    amask = avec > avec;
    // check
    alignas(vec_t::alignment) std::array<std::uint64_t, vec_t::width>
        ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
    amask.store(ascalararr.data());
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        // type conversion make lvalue in rvalue, needed pre-c++17
        BOOST_CHECK_EQUAL(ascalararr[i], (std::uint64_t)mask_t::false_v);
    }
 
    double bval = 3.0;
    vec_t bvec(bval);
 
    amask = avec > bvec;
    // check
    amask.store(ascalararr.data());
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        // type conversion make lvalue in rvalue, needed pre-c++17
        BOOST_CHECK_EQUAL(ascalararr[i], (std::uint64_t)mask_t::true_v);
    }
 
    double cval = 5.0;
    vec_t cvec(cval);
 
    amask = avec > cvec;
    // check
    amask.store(ascalararr.data());
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        // type conversion make lvalue in rvalue, needed pre-c++17
        BOOST_CHECK_EQUAL(ascalararr[i], (std::uint64_t)mask_t::false_v);
    }
 
    if (vec_t::width == 4)
    {
        alignas(vec_t::alignment) std::array<double, 4> ascalararr2{
            {1.0, 2.0, 3.0, 4.0}}; // double brace to deal with gcc 4.8.5 ...
        double dval = 2.0;
        vec_t dvec(dval);
        vec_t evec;
        evec.load(ascalararr2.data());
 
        amask = dvec > evec;
        // check
        for (size_t i = 0; i < vec_t::width; ++i)
        {
            BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]),
                              dval > ascalararr2[i]);
        }
    }
 
    if (vec_t::width == 8)
    {
        alignas(vec_t::alignment) std::array<double, 8> ascalararr2{
            {1.0, 2.0, 3.0, 4.0, 3.0, 2.0,
             1.0}}; // double brace to deal with gcc 4.8.5 ...
        double dval = 2.0;
        vec_t dvec(dval);
        vec_t evec;
        evec.load(ascalararr2.data());
 
        amask = dvec > evec;
        // check
        for (size_t i = 0; i < vec_t::width; ++i)
        {
            BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]),
                              dval > ascalararr2[i]);
        }
    }
}

BOOST_AUTO_TEST_CASE() [13/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_io

)

Definition at line 1061 of file TestSimdLibDouble.cpp.

{
    vec_t avec(3.14);
    std::cout << avec << std::endl;
}

BOOST_AUTO_TEST_CASE() [14/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_load

)

Definition at line 178 of file TestSimdLibDouble.cpp.

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

BOOST_AUTO_TEST_CASE() [15/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_load_aligned

)

Definition at line 194 of file TestSimdLibDouble.cpp.

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

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [16/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_load_implicit

)

Definition at line 186 of file TestSimdLibDouble.cpp.

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

BOOST_AUTO_TEST_CASE() [17/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_load_interleave_unload

)

Definition at line 830 of file TestSimdLibDouble.cpp.

{
    constexpr size_t nDof{5};
    // no padding in load_interleave deinterleave_store
    constexpr size_t nEle{vec_t::width * 5};
    constexpr size_t nDofBlock = nDof * vec_t::width;
 
    constexpr size_t size{nDof * nEle};
    std::array<double, size> dofScalarArr{{}};
    for (size_t i = 0; i < size; ++i)
    {
        dofScalarArr[i] = i;
    }
 
    // number of blocks
    size_t nBlock = nEle / vec_t::width;
 
    // aligned vector
    std::vector<vec_t, allocator<vec_t>> dofVectorArr(nDof);
 
    double *dataPtr = dofScalarArr.data();
    // loop over blocks vec_t::width elements at the time
    for (size_t b = 0; b < nBlock; ++b)
    {
        // load
        load_interleave(dataPtr, nDof, dofVectorArr);
 
        // manipulate each block
        for (size_t j = 0; j < nDof; ++j)
        {
            dofVectorArr[j] = dofVectorArr[j] + j;
        }
 
        // store
        deinterleave_store(dofVectorArr, nDof, dataPtr);
        dataPtr += nDofBlock;
    }
 
    // check
    for (size_t b = 0, i = 0; b < nBlock; ++b)
    {
        for (size_t j = 0; j < nDof; ++j, ++i)
        {
            BOOST_CHECK_EQUAL(dofScalarArr[i], i + j);
        }
    }
}

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

BOOST_AUTO_TEST_CASE() [18/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_load_unaligned

)

Definition at line 202 of file TestSimdLibDouble.cpp.

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

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [19/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_log

)

Definition at line 697 of file TestSimdLibDouble.cpp.

{
    double val = 4.0;
    vec_t avec(val);
    vec_t alog = log(avec);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    alog.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], std::log(val));
    }
}

References tinysimd::log().

BOOST_AUTO_TEST_CASE() [20/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_logic_and

)

Definition at line 792 of file TestSimdLibDouble.cpp.

{
    double aval = 4.0;
    vec_t avec(aval);
    using mask_t = simd<bool, vec_t::width>;
    mask_t amask;
 
    alignas(vec_t::alignment) std::array<std::uint64_t, vec_t::width>
        ascalararr{{}}; // double brace to deal with gcc 4.8.5 ...
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        ascalararr[i] = mask_t::true_v;
    }
    amask.load(ascalararr.data());
 
    // check
    BOOST_CHECK_EQUAL(amask && false, false);
    BOOST_CHECK_EQUAL(amask && true, true);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        ascalararr[i] = mask_t::false_v;
    }
    amask.load(ascalararr.data());
 
    // check
    BOOST_CHECK_EQUAL(amask && false, false);
    BOOST_CHECK_EQUAL(amask && true, false);
 
    if (vec_t::width > 1)
    {
        ascalararr[0] = mask_t::true_v;
        // check
        BOOST_CHECK_EQUAL(amask && false, false);
        BOOST_CHECK_EQUAL(amask && true, false);
    }
}

BOOST_AUTO_TEST_CASE() [21/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_longsimd_interleave_helpers

)

Definition at line 961 of file TestSimdLibDouble.cpp.

{
    {
        constexpr size_t nDof      = 5;
        constexpr size_t nBlocks   = 3;
        constexpr size_t nEle      = long_vec_t::width * nBlocks;
        constexpr size_t blockSize = nDof * long_vec_t::width;
        constexpr size_t size      = nDof * nEle;
 
        std::array<double, size> data{{}};
        for (size_t i = 0; i < size; ++i)
        {
            data[i] = static_cast<double>(i);
        }
 
        std::vector<long_vec_t, allocator<long_vec_t>> work(nDof);
 
        for (size_t block = 0; block < nBlocks; ++block)
        {
            double *dataPtr = data.data() + block * blockSize;
            load_interleave(dataPtr, nDof, work);
            for (size_t j = 0; j < nDof; ++j)
            {
                work[j] += static_cast<double>(j + 1);
            }
            deinterleave_store(work, nDof, dataPtr);
        }
 
        for (size_t block = 0; block < nBlocks; ++block)
        {
            for (size_t lane = 0; lane < long_vec_t::width; ++lane)
            {
                for (size_t dof = 0; dof < nDof; ++dof)
                {
                    const auto idx = block * blockSize + lane * nDof + dof;
                    BOOST_CHECK_EQUAL(data[idx],
                                      static_cast<double>(idx + dof + 1));
                }
            }
        }
    }
 
    {
        constexpr size_t nDof          = 4;
        constexpr size_t skipPads      = long_vec_t::width > 1 ? 1 : 0;
        constexpr size_t activeWidth   = long_vec_t::width - skipPads;
        constexpr size_t unalignedSize = nDof * long_vec_t::width;
        constexpr size_t paddedSize    = nDof * activeWidth;
 
        std::array<double, unalignedSize> data{{}};
        for (size_t i = 0; i < data.size(); ++i)
        {
            data[i] = static_cast<double>(100 + i);
        }
 
        std::vector<long_vec_t, allocator<long_vec_t>> work(nDof);
        load_unalign_interleave(data.data(), nDof, work);
        for (size_t j = 0; j < nDof; ++j)
        {
            work[j] += static_cast<double>(2 * j + 1);
        }
        std::array<double, unalignedSize> out{{}};
        deinterleave_unalign_store(work, nDof, out.data());
 
        for (size_t lane = 0; lane < long_vec_t::width; ++lane)
        {
            for (size_t dof = 0; dof < nDof; ++dof)
            {
                const auto idx = lane * nDof + dof;
                BOOST_CHECK_EQUAL(out[idx],
                                  data[idx] + static_cast<double>(2 * dof + 1));
            }
        }
 
        std::array<double, paddedSize> padded{{}};
        for (size_t i = 0; i < padded.size(); ++i)
        {
            padded[i] = static_cast<double>(200 + i);
        }
 
        load_unalign_interleave_skipPads(padded.data(), nDof, skipPads, work);
        for (auto &value : work)
        {
            value += 3.0;
        }
        std::array<double, paddedSize> paddedOut{{}};
        deinterleave_unalign_store_skipPads(work, nDof, skipPads,
                                            paddedOut.data());
 
        for (size_t lane = 0; lane < activeWidth; ++lane)
        {
            for (size_t dof = 0; dof < nDof; ++dof)
            {
                const auto idx = lane * nDof + dof;
                BOOST_CHECK_EQUAL(paddedOut[idx], padded[idx] + 3.0);
            }
        }
    }
}

References tinysimd::deinterleave_store(), tinysimd::deinterleave_unalign_store(), tinysimd::deinterleave_unalign_store_skipPads(), tinysimd::load_interleave(), tinysimd::load_unalign_interleave(), and tinysimd::load_unalign_interleave_skipPads().

BOOST_AUTO_TEST_CASE() [22/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_longsimd_mixed_arithmetic

)

Definition at line 889 of file TestSimdLibDouble.cpp.

{
    alignas(long_vec_t::alignment) std::array<double, long_vec_t::width>
        lhsData{{}};
    alignas(vec_t::alignment) std::array<double, vec_t::width> rhsData{{}};
 
    for (size_t i = 0; i < lhsData.size(); ++i)
    {
        lhsData[i] = static_cast<double>(i + 1);
    }
    for (size_t i = 0; i < rhsData.size(); ++i)
    {
        rhsData[i] = static_cast<double>(10 * (i + 1));
    }
 
    long_vec_t lhs;
    lhs.load(lhsData.data(), is_aligned);
 
    vec_t rhs;
    rhs.load(rhsData.data(), is_aligned);
 
    auto sum         = lhs + rhs;
    auto reverseSum  = rhs + lhs;
    auto scalarRight = lhs + 2.5;
    auto scalarLeft  = 100.0 - lhs;
    auto scaled      = lhs * 2.0;
 
    long_vec_t acc(1.0);
    acc.fma(lhs, rhs);
 
    alignas(long_vec_t::alignment) std::array<double, long_vec_t::width> tmp{
        {}};
    sum.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        const auto chunkLane = i % vec_t::width;
        BOOST_CHECK_EQUAL(tmp[i], lhsData[i] + rhsData[chunkLane]);
    }
 
    reverseSum.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        const auto chunkLane = i % vec_t::width;
        BOOST_CHECK_EQUAL(tmp[i], lhsData[i] + rhsData[chunkLane]);
    }
 
    scalarRight.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        BOOST_CHECK_EQUAL(tmp[i], lhsData[i] + 2.5);
    }
 
    scalarLeft.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        BOOST_CHECK_EQUAL(tmp[i], 100.0 - lhsData[i]);
    }
 
    scaled.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        BOOST_CHECK_EQUAL(tmp[i], lhsData[i] * 2.0);
    }
 
    acc.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        const auto chunkLane = i % vec_t::width;
        BOOST_CHECK_EQUAL(tmp[i], 1.0 + lhsData[i] * rhsData[chunkLane]);
    }
}

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [23/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_longsimd_width

)

Definition at line 878 of file TestSimdLibDouble.cpp.

{
    BOOST_CHECK_EQUAL(default_long_vec_t::width,
                      vec_t::width * tinysimd::PACKMULTIPLIER);
 
    BOOST_CHECK_EQUAL(long_vec_t::width, 3 * vec_t::width);
    BOOST_CHECK_EQUAL(long_vec_t::alignment, vec_t::alignment);
    BOOST_CHECK_EQUAL(sizeof(long_vec_t), sizeof(double) * long_vec_t::width);
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<long_vec_t>, true);
}

References tinysimd::PACKMULTIPLIER.

BOOST_AUTO_TEST_CASE() [24/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_mem_size

)

Definition at line 153 of file TestSimdLibDouble.cpp.

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

BOOST_AUTO_TEST_CASE() [25/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_mul_binary

)

Definition at line 595 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 * avec2;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
    }
}

BOOST_AUTO_TEST_CASE() [26/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_mul_unary

)

Definition at line 527 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res *= avec;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
    }
}

BOOST_AUTO_TEST_CASE() [27/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_scatter64

)

Definition at line 429 of file TestSimdLibDouble.cpp.

{
    vec_t avec;
    using index_t = simd<size_t>;
    index_t aindexvec;
 
    // create and fill index
    std::array<size_t, vec_t::width> aindex;
    aindex[0] = 1;
    if (vec_t::width > 1)
    {
        aindex[1] = 3;
    }
    if (vec_t::width > 2)
    {
        aindex[2] = 5;
        aindex[3] = 6;
    }
    if (vec_t::width > 4)
    {
        aindex[4] = 8;
        aindex[5] = 15;
        aindex[6] = 20;
        aindex[7] = 30;
    }
 
    // load index
    aindexvec.load(aindex.data(), is_not_aligned);
 
    // create scalar array
    constexpr size_t scalarArraySize = 32;
    std::array<double, scalarArraySize> ascalararr;
 
    // fill vector
    alignas(vec_t::alignment) std::array<double, vec_t::width> avecarr{{}};
    avecarr[0] = 10;
    if (vec_t::width > 1)
    {
        avecarr[1] = 9;
    }
 
    if (vec_t::width > 2)
    {
        avecarr[2] = 8;
        avecarr[3] = 7;
    }
    if (vec_t::width > 4)
    {
        avecarr[4] = 4;
        avecarr[5] = 3;
        avecarr[6] = 2;
        avecarr[7] = 1;
    }
    avec.load(avecarr.data());
 
    avec.scatter(ascalararr.data(), aindexvec);
 
    // check
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(avec[i], ascalararr[aindex[i]]);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [28/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_sqrt

)

Definition at line 667 of file TestSimdLibDouble.cpp.

{
    double val = 4.0;
    vec_t avec(val);
    vec_t asqrt = sqrt(avec);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    asqrt.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], std::sqrt(val));
    }
}

References tinysimd::sqrt().

BOOST_AUTO_TEST_CASE() [29/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_store

)

Definition at line 258 of file TestSimdLibDouble.cpp.

{
    double val = 4.0;
    vec_t avec(val);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

BOOST_AUTO_TEST_CASE() [30/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_store_aligned

)

Definition at line 272 of file TestSimdLibDouble.cpp.

{
    double val = 4.0;
    vec_t avec(val);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data(), is_aligned);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [31/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_store_non_temporal

)

Definition at line 300 of file TestSimdLibDouble.cpp.

{
    double val = 4.0;
    vec_t avec(val);
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data(), is_not_reused);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

References tinysimd::is_not_reused.

BOOST_AUTO_TEST_CASE() [32/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_store_unaligned

)

Definition at line 286 of file TestSimdLibDouble.cpp.

{
    double val = 4.0;
    vec_t avec(val);
    std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data(), is_not_aligned);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [33/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_sub_binary

)

Definition at line 578 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 - avec2;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
    }
}

BOOST_AUTO_TEST_CASE() [34/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_sub_unary

)

Definition at line 510 of file TestSimdLibDouble.cpp.

{
    double val1 = -4.0;
    double val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res -= avec;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
    }
}

BOOST_AUTO_TEST_CASE() [35/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_subscript_assign_read

)

Definition at line 321 of file TestSimdLibDouble.cpp.

{
    vec_t avec;
    alignas(vec_t::alignment) std::array<double, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        ascalararr[i] = i;
    }
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        avec[i] = ascalararr[i];
    }
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], avec[i]);
    }
}

BOOST_AUTO_TEST_CASE() [36/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_type_traits

)

Definition at line 130 of file TestSimdLibDouble.cpp.

{
    {
        using namespace details;
 
        BOOST_CHECK_EQUAL(has_width<double>::value, false);
        BOOST_CHECK_EQUAL(has_width<vec_t>::value, true);
 
        BOOST_CHECK_EQUAL(has_alignment<double>::value, false);
        BOOST_CHECK_EQUAL(has_alignment<vec_t>::value, true);
 
        BOOST_CHECK_EQUAL(has_scalarType<double>::value, false);
        BOOST_CHECK_EQUAL(has_scalarType<vec_t>::value, true);
    }
 
    BOOST_CHECK_EQUAL(is_vector_v<double>, false);
    BOOST_CHECK_EQUAL(is_vector_v<vec_t>, true);
 
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<double>, false);
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<simd<int>>, false);
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<vec_t>, true);
}

References tinysimd::is_vector_floating_point_v.

BOOST_AUTO_TEST_CASE() [37/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibDouble_width_alignment

)

Definition at line 89 of file TestSimdLibDouble.cpp.

{
    std::size_t width, alignment;
 
#if defined(USING_SCALAR)
    std::cout << "scalar double" << std::endl;
#endif
#if defined(USING_SSE2)
    std::cout << "sse2 double" << std::endl;
#endif
#if defined(USING_AVX2)
    std::cout << "avx2 double" << std::endl;
#endif
#if defined(USING_AVX512)
    std::cout << "avx512 double" << std::endl;
#endif
#if defined(USING_SVE)
    std::cout << "sve double" << std::endl;
#endif
 
    // double
    width     = simd<double>::width;
    alignment = simd<double>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
    BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
    // std::int32_t index forcing # of lanes
    width     = simd<std::int32_t, vec_t::width>::width;
    alignment = simd<std::int32_t, vec_t::width>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
    // std::int64_t index forcing # of lanes
    width     = simd<std::int64_t, vec_t::width>::width;
    alignment = simd<std::int64_t, vec_t::width>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
    BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
    // std::int64_t default index
    width     = simd<std::int64_t>::width;
    alignment = simd<std::int64_t>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_64BITS);
    BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
}

References ALIGNMENT, and NUM_LANES_64BITS.

BOOST_AUTO_TEST_CASE() [38/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_abs

)

Definition at line 604 of file TestSimdLibSingle.cpp.

{
    float val = -4.0;
    vec_t avec(val);
    vec_t aabs = abs(avec);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    aabs.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], std::abs(val));
    }
}

References tinysimd::abs().

BOOST_AUTO_TEST_CASE() [39/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_add_binary

)

Definition at line 483 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 + avec2;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
    }
}

BOOST_AUTO_TEST_CASE() [40/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_add_mul

)

Definition at line 551 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.0;
    float val3 = 2.0;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t avec3(val3);
    vec_t res = avec1 + avec2 * avec3;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 + val3);
    }
}

BOOST_AUTO_TEST_CASE() [41/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_add_unary

)

Definition at line 415 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res += avec;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2);
    }
}

BOOST_AUTO_TEST_CASE() [42/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_ctors

)

Definition at line 147 of file TestSimdLibSingle.cpp.

{
    [[maybe_unused]] vec_t avec1;
 
    vec_t::scalarType ascalar = 0;
    vec_t avec2(ascalar);
    [[maybe_unused]] vec_t avec3{ascalar};
    vec_t avec4 = ascalar;
 
    [[maybe_unused]] vec_t avec5(avec2);
    [[maybe_unused]] vec_t avec6{avec4};
 
    [[maybe_unused]] vec_t avec7(avec2._data);
    [[maybe_unused]] vec_t avec8{avec2._data};
 
    vec_t::vectorType anative;
    [[maybe_unused]] vec_t avec9(anative);
    [[maybe_unused]] vec_t avec10{anative};
}

BOOST_AUTO_TEST_CASE() [43/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_div_binary

)

Definition at line 534 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 / avec2;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
    }
}

BOOST_AUTO_TEST_CASE() [44/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_div_unary

)

Definition at line 466 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res /= avec;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 / val2);
    }
}

BOOST_AUTO_TEST_CASE() [45/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_fused_add_mul

)

Definition at line 570 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 1.5;
    float val3 = 5.0;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t avec3(val3);
    avec1.fma(avec2, avec3);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    avec1.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 + val2 * val3);
    }
}

BOOST_AUTO_TEST_CASE() [46/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_gather32

)

Definition at line 286 of file TestSimdLibSingle.cpp.

{
    vec_t avec;
    using index_t = simd<std::uint32_t>;
    index_t aindexvec;
 
    // create and fill index
    std::array<std::uint32_t, vec_t::width> aindex;
    aindex[0] = 0;
    if (vec_t::width > 2)
    {
        aindex[1] = 3;
        aindex[2] = 5;
        aindex[3] = 6;
    }
    if (vec_t::width > 4)
    {
        aindex[4] = 8;
        aindex[5] = 15;
        aindex[6] = 20;
        aindex[7] = 23;
    }
    if (vec_t::width > 8)
    {
        aindex[8]  = 24;
        aindex[9]  = 28;
        aindex[10] = 33;
        aindex[11] = 40;
        aindex[12] = 41;
        aindex[13] = 45;
        aindex[14] = 60;
        aindex[15] = 61;
    }
 
    // load index
    aindexvec.load(aindex.data(), is_not_aligned);
 
    // create and fill scalar array
    constexpr size_t scalarArraySize = 64;
    std::array<float, scalarArraySize> ascalararr;
    for (size_t i = 0; i < scalarArraySize; ++i)
    {
        ascalararr[i] = i;
    }
 
    avec.gather(ascalararr.data(), aindexvec);
 
    // check
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[aindex[i]], avec[i]);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [47/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_greater

)

Definition at line 634 of file TestSimdLibSingle.cpp.

{
    float aval = 4.0;
    vec_t avec(aval);
    using mask_t = simd<bool, vec_t::width>;
    mask_t amask;
 
    amask = avec > avec;
    // check
    alignas(vec_t::alignment) std::array<std::uint32_t, vec_t::width>
        ascalararr{{}}; // float brace to deal with gcc 4.8.5 ...
    amask.store(ascalararr.data());
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        // type conversion make lvalue in rvalue, needed pre-c++17
        BOOST_CHECK_EQUAL(ascalararr[i], (std::uint32_t)mask_t::false_v);
    }
 
    float bval = 3.0;
    vec_t bvec(bval);
 
    amask = avec > bvec;
    // check
    amask.store(ascalararr.data());
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        // type conversion make lvalue in rvalue, needed pre-c++17
        BOOST_CHECK_EQUAL(ascalararr[i], (std::uint32_t)mask_t::true_v);
    }
 
    float cval = 5.0;
    vec_t cvec(cval);
 
    amask = avec > cvec;
    // check
    amask.store(ascalararr.data());
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        // type conversion make lvalue in rvalue, needed pre-c++17
        BOOST_CHECK_EQUAL(ascalararr[i], (std::uint32_t)mask_t::false_v);
    }
 
    if (vec_t::width == 4)
    {
        alignas(vec_t::alignment) std::array<float, 4> ascalararr2{
            {1.0, 2.0, 3.0, 4.0}}; // float brace to deal with gcc 4.8.5 ...
        float dval = 2.0;
        vec_t dvec(dval);
        vec_t evec;
        evec.load(ascalararr2.data());
 
        amask = dvec > evec;
        // check
        for (size_t i = 0; i < vec_t::width; ++i)
        {
            BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]), dvec[i] > evec[i]);
        }
    }
 
    if (vec_t::width == 8)
    {
        alignas(vec_t::alignment) std::array<float, 8> ascalararr2{
            {1.0, 2.0, 3.0, 4.0, 3.0, 2.0,
             1.0}}; // double brace to deal with gcc 4.8.5 ...
        float dval = 2.0;
        vec_t dvec(dval);
        vec_t evec;
        evec.load(ascalararr2.data());
 
        amask = dvec > evec;
        // check
        for (size_t i = 0; i < vec_t::width; ++i)
        {
            BOOST_CHECK_EQUAL(static_cast<bool>(amask[i]),
                              dval > ascalararr2[i]);
        }
    }
}

BOOST_AUTO_TEST_CASE() [48/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_io

)

Definition at line 874 of file TestSimdLibSingle.cpp.

{
    vec_t avec(3.14);
    std::cout << avec << std::endl;
}

BOOST_AUTO_TEST_CASE() [49/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_load

)

Definition at line 167 of file TestSimdLibSingle.cpp.

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

BOOST_AUTO_TEST_CASE() [50/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_load_aligned

)

Definition at line 183 of file TestSimdLibSingle.cpp.

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

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [51/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_load_implicit

)

Definition at line 175 of file TestSimdLibSingle.cpp.

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

BOOST_AUTO_TEST_CASE() [52/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_load_interleave_unload

)

Definition at line 751 of file TestSimdLibSingle.cpp.

{
    constexpr size_t nDof{5};
    // no padding in load_interleave deinterleave_store
    constexpr size_t nEle{vec_t::width * 5};
    constexpr size_t nDofBlock = nDof * vec_t::width;
 
    constexpr size_t size{nDof * nEle};
    std::array<float, size> dofScalarArr{{}};
    for (size_t i = 0; i < size; ++i)
    {
        dofScalarArr[i] = i;
    }
 
    // number of blocks
    size_t nBlock = nEle / vec_t::width;
 
    // aligned vector
    std::vector<vec_t, allocator<vec_t>> dofVectorArr(nDof);
 
    float *dataPtr = dofScalarArr.data();
    // loop over blocks vec_t::width elements at the time
    for (size_t b = 0; b < nBlock; ++b)
    {
        // load
        load_interleave(dataPtr, nDof, dofVectorArr);
 
        // manipulate each block
        for (size_t j = 0; j < nDof; ++j)
        {
            dofVectorArr[j] = dofVectorArr[j] + j;
        }
 
        // store
        deinterleave_store(dofVectorArr, nDof, dataPtr);
        dataPtr += nDofBlock;
    }
 
    // check
    for (size_t b = 0, i = 0; b < nBlock; ++b)
    {
        for (size_t j = 0; j < nDof; ++j, ++i)
        {
            BOOST_CHECK_EQUAL(dofScalarArr[i], i + j);
        }
    }
}

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

BOOST_AUTO_TEST_CASE() [53/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_load_unaligned

)

Definition at line 191 of file TestSimdLibSingle.cpp.

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

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [54/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_log

)

Definition at line 619 of file TestSimdLibSingle.cpp.

{
    float val = 4.0;
    vec_t avec(val);
    vec_t alog = log(avec);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    alog.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], std::log(val));
    }
}

References tinysimd::log().

BOOST_AUTO_TEST_CASE() [55/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_logic_and

)

Definition at line 713 of file TestSimdLibSingle.cpp.

{
    float aval = 4.0;
    vec_t avec(aval);
    using mask_t = simd<bool, vec_t::width>;
    mask_t amask;
 
    alignas(vec_t::alignment) std::array<std::uint32_t, vec_t::width>
        ascalararr{{}}; // float brace to deal with gcc 4.8.5 ...
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        ascalararr[i] = mask_t::true_v;
    }
    amask.load(ascalararr.data());
 
    // check
    BOOST_CHECK_EQUAL(amask && false, false);
    BOOST_CHECK_EQUAL(amask && true, true);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        ascalararr[i] = mask_t::false_v;
    }
    amask.load(ascalararr.data());
 
    // check
    BOOST_CHECK_EQUAL(amask && false, false);
    BOOST_CHECK_EQUAL(amask && true, false);
 
    if (vec_t::width > 1)
    {
        ascalararr[0] = mask_t::true_v;
        // check
        BOOST_CHECK_EQUAL(amask && false, false);
        BOOST_CHECK_EQUAL(amask && true, false);
    }
}

BOOST_AUTO_TEST_CASE() [56/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_longsimd_interleave_helpers

)

Definition at line 834 of file TestSimdLibSingle.cpp.

{
    constexpr size_t nDof      = 3;
    constexpr size_t nBlocks   = 2;
    constexpr size_t nEle      = long_vec_t::width * nBlocks;
    constexpr size_t blockSize = nDof * long_vec_t::width;
    constexpr size_t size      = nDof * nEle;
 
    std::array<float, size> data{{}};
    for (size_t i = 0; i < size; ++i)
    {
        data[i] = static_cast<float>(i);
    }
 
    std::vector<long_vec_t, allocator<long_vec_t>> work(nDof);
 
    for (size_t block = 0; block < nBlocks; ++block)
    {
        float *dataPtr = data.data() + block * blockSize;
        load_interleave(dataPtr, nDof, work);
        for (size_t j = 0; j < nDof; ++j)
        {
            work[j] += static_cast<float>(j + 1);
        }
        deinterleave_store(work, nDof, dataPtr);
    }
 
    for (size_t block = 0; block < nBlocks; ++block)
    {
        for (size_t lane = 0; lane < long_vec_t::width; ++lane)
        {
            for (size_t dof = 0; dof < nDof; ++dof)
            {
                const auto idx = block * blockSize + lane * nDof + dof;
                BOOST_CHECK_EQUAL(data[idx], static_cast<float>(idx + dof + 1));
            }
        }
    }
}

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

BOOST_AUTO_TEST_CASE() [57/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_longsimd_mixed_arithmetic

)

Definition at line 799 of file TestSimdLibSingle.cpp.

{
    alignas(long_vec_t::alignment) std::array<float, long_vec_t::width> lhsData{
        {}};
    alignas(vec_t::alignment) std::array<float, vec_t::width> rhsData{{}};
 
    for (size_t i = 0; i < lhsData.size(); ++i)
    {
        lhsData[i] = static_cast<float>(i + 1);
    }
    for (size_t i = 0; i < rhsData.size(); ++i)
    {
        rhsData[i] = static_cast<float>(i + 1);
    }
 
    long_vec_t lhs;
    lhs.load(lhsData.data(), is_aligned);
 
    vec_t rhs;
    rhs.load(rhsData.data(), is_aligned);
 
    auto mixed = lhs + rhs;
    mixed += rhs;
    mixed += 2.0f;
 
    alignas(long_vec_t::alignment) std::array<float, long_vec_t::width> tmp{{}};
    mixed.store(tmp.data(), is_aligned);
    for (size_t i = 0; i < tmp.size(); ++i)
    {
        const auto chunkLane = i % vec_t::width;
        BOOST_CHECK_EQUAL(tmp[i],
                          lhsData[i] + 2.0f * rhsData[chunkLane] + 2.0f);
    }
}

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [58/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_mem_size

)

Definition at line 142 of file TestSimdLibSingle.cpp.

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

BOOST_AUTO_TEST_CASE() [59/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_mul_binary

)

Definition at line 517 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 * avec2;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
    }
}

BOOST_AUTO_TEST_CASE() [60/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_mul_unary

)

Definition at line 449 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res *= avec;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 * val2);
    }
}

BOOST_AUTO_TEST_CASE() [61/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_scatter32

)

Definition at line 340 of file TestSimdLibSingle.cpp.

{
    vec_t avec;
    using index_t = simd<std::uint32_t>;
    index_t aindexvec;
 
    // create and fill index
    std::array<std::uint32_t, vec_t::width> aindex;
    aindex[0] = 1;
    if (vec_t::width > 1)
    {
        aindex[1] = 3;
    }
    if (vec_t::width > 2)
    {
        aindex[2] = 5;
        aindex[3] = 6;
    }
    if (vec_t::width > 4)
    {
        aindex[4] = 8;
        aindex[5] = 15;
        aindex[6] = 20;
        aindex[7] = 30;
    }
    if (vec_t::width > 8)
    {
        aindex[8]  = 31;
        aindex[9]  = 32;
        aindex[10] = 35;
        aindex[11] = 40;
        aindex[12] = 41;
        aindex[13] = 45;
        aindex[14] = 60;
        aindex[15] = 61;
    }
 
    // load index
    aindexvec.load(aindex.data(), is_not_aligned);
 
    // create scalar array
    constexpr size_t scalarArraySize = 64;
    std::array<float, scalarArraySize> ascalararr;
 
    // fill vector
    alignas(vec_t::alignment) std::array<float, vec_t::width> avecarr{{}};
    avecarr[0] = 10;
    if (vec_t::width > 1)
    {
        avecarr[1] = 9;
    }
 
    if (vec_t::width > 2)
    {
        avec[2] = 8;
        avec[3] = 7;
    }
    if (vec_t::width > 4)
    {
        avec[4] = 4;
        avec[5] = 3;
        avec[6] = 2;
        avec[7] = 1;
    }
    avec.load(avecarr.data());
 
    avec.scatter(ascalararr.data(), aindexvec);
 
    // check
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(avec[i], ascalararr[aindex[i]]);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [62/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_sqrt

)

Definition at line 589 of file TestSimdLibSingle.cpp.

{
    float val = 4.0;
    vec_t avec(val);
    vec_t asqrt = sqrt(avec);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    asqrt.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], std::sqrt(val));
    }
}

References tinysimd::sqrt().

BOOST_AUTO_TEST_CASE() [63/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_store

)

Definition at line 199 of file TestSimdLibSingle.cpp.

{
    float val = 4.0;
    vec_t avec(val);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

BOOST_AUTO_TEST_CASE() [64/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_store_aligned

)

Definition at line 213 of file TestSimdLibSingle.cpp.

{
    float val = 4.0;
    vec_t avec(val);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data(), is_aligned);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [65/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_store_non_temporal

)

Definition at line 241 of file TestSimdLibSingle.cpp.

{
    float val = 4.0;
    vec_t avec(val);
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data(), is_not_reused);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

References tinysimd::is_not_reused.

BOOST_AUTO_TEST_CASE() [66/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_store_unaligned

)

Definition at line 227 of file TestSimdLibSingle.cpp.

{
    float val = 4.0;
    vec_t avec(val);
    std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    avec.store(ascalararr.data(), is_not_aligned);
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val);
    }
}

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [67/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_sub_binary

)

Definition at line 500 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.5;
    vec_t avec1(val1);
    vec_t avec2(val2);
    vec_t res = avec1 - avec2;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
    }
}

BOOST_AUTO_TEST_CASE() [68/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_sub_unary

)

Definition at line 432 of file TestSimdLibSingle.cpp.

{
    float val1 = -4.0;
    float val2 = 2.0;
    vec_t res(val1);
    vec_t avec(val2);
    res -= avec;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // float brace to deal with gcc 4.8.5 ...
    res.store(ascalararr.data());
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], val1 - val2);
    }
}

BOOST_AUTO_TEST_CASE() [69/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibFloat_type_traits

)

Definition at line 121 of file TestSimdLibSingle.cpp.

{
    using namespace details;
 
    BOOST_CHECK_EQUAL(has_width<float>::value, false);
    BOOST_CHECK_EQUAL(has_width<vec_t>::value, true);
 
    BOOST_CHECK_EQUAL(has_alignment<float>::value, false);
    BOOST_CHECK_EQUAL(has_alignment<vec_t>::value, true);
 
    BOOST_CHECK_EQUAL(has_scalarType<float>::value, false);
    BOOST_CHECK_EQUAL(has_scalarType<vec_t>::value, true);
 
    BOOST_CHECK_EQUAL(is_vector_v<float>, false);
    BOOST_CHECK_EQUAL(is_vector_v<vec_t>, true);
 
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<float>, false);
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<simd<int>>, false);
    BOOST_CHECK_EQUAL(is_vector_floating_point_v<vec_t>, true);
}

References tinysimd::is_vector_floating_point_v.

BOOST_AUTO_TEST_CASE() [70/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibInt32_load

)

Definition at line 234 of file TestSimdLibDouble.cpp.

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

BOOST_AUTO_TEST_CASE() [71/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibInt32_load_aligned

)

Definition at line 242 of file TestSimdLibDouble.cpp.

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

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [72/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibInt32_load_unaligned

)

Definition at line 250 of file TestSimdLibDouble.cpp.

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

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [73/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibInt64_load

)

Definition at line 210 of file TestSimdLibDouble.cpp.

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

BOOST_AUTO_TEST_CASE() [74/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibInt64_load_aligned

)

Definition at line 218 of file TestSimdLibDouble.cpp.

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

References tinysimd::is_aligned.

BOOST_AUTO_TEST_CASE() [75/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibInt64_load_unaligned

)

Definition at line 226 of file TestSimdLibDouble.cpp.

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

References tinysimd::is_not_aligned.

BOOST_AUTO_TEST_CASE() [76/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibSingle_broadcast

)

Definition at line 255 of file TestSimdLibSingle.cpp.

{
    // explictly float literal for
    // Visual Studio 14 2015 Win64 compiler bug
    vec_t::scalarType ascalar{3.333f};
    vec_t avec;
    avec.broadcast(ascalar);
}

BOOST_AUTO_TEST_CASE() [77/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibSingle_subscript_assign_read

)

Definition at line 264 of file TestSimdLibSingle.cpp.

{
    vec_t avec;
    alignas(vec_t::alignment) std::array<float, vec_t::width> ascalararr{
        {}}; // double brace to deal with gcc 4.8.5 ...
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        ascalararr[i] = i;
    }
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        avec[i] = ascalararr[i];
    }
 
    for (size_t i = 0; i < vec_t::width; ++i)
    {
        BOOST_CHECK_EQUAL(ascalararr[i], avec[i]);
    }
}

BOOST_AUTO_TEST_CASE() [78/78]

Nektar::SimdLibTests::BOOST_AUTO_TEST_CASE

(

SimdLibSingle_width_alignment

)

Definition at line 87 of file TestSimdLibSingle.cpp.

{
    std::size_t width, alignment;
 
#if defined(USING_SCALAR)
    std::cout << "scalar float" << std::endl;
#endif
#if defined(USING_AVX2)
    std::cout << "avx2 float" << std::endl;
#endif
#if defined(USING_AVX512)
    std::cout << "avx512 float" << std::endl;
#endif
#if defined(USING_SVE)
    std::cout << "sve float" << std::endl;
#endif
 
    // float
    width     = simd<float>::width;
    alignment = simd<float>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_32BITS);
    BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
    // std::int32_t index forcing # of lanes
    width     = simd<std::int32_t, vec_t::width>::width;
    alignment = simd<std::int32_t, vec_t::width>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_32BITS);
    BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
    // std::int32_t default index
    width     = simd<std::int32_t>::width;
    alignment = simd<std::int32_t>::alignment;
    BOOST_CHECK_EQUAL(width, NUM_LANES_32BITS);
    BOOST_CHECK_EQUAL(alignment, ALIGNMENT);
}

References ALIGNMENT, and NUM_LANES_32BITS.