ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updating Kokkos lib to 2.03.00

Browse Source
This commit is contained in:
Stan Moore
2017-04-25 13:48:51 -06:00
parent 9f6e126a2f
commit 8910ec6e59
261 changed files with 27816 additions and 17799 deletions
Download Patch File Download Diff File Expand all files Collapse all files

321
lib/kokkos/core/unit_test/TestUtilities.hpp
View File

@ -49,258 +49,253 @@
#include <Kokkos_Core.hpp>
/*--------------------------------------------------------------------------*/
namespace Test {
inline
void test_utilities()
{
using namespace Kokkos::Impl;
{
using i = integer_sequence<int>;
using j = make_integer_sequence<int,0>;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
{
using i = integer_sequence< int >;
using j = make_integer_sequence< int, 0 >;
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 0u, "Error: integer_sequence.size()" );
}
{
using i = integer_sequence<int,0>;
using j = make_integer_sequence<int,1>;
using i = integer_sequence< int, 0 >;
using j = make_integer_sequence< int, 1 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 1u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1>;
using j = make_integer_sequence<int,2>;
using i = integer_sequence< int, 0, 1 >;
using j = make_integer_sequence< int, 2 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 2u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2>;
using j = make_integer_sequence<int,3>;
using i = integer_sequence< int, 0, 1, 2 >;
using j = make_integer_sequence< int, 3 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 3u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3>;
using j = make_integer_sequence<int,4>;
using i = integer_sequence< int, 0, 1, 2, 3 >;
using j = make_integer_sequence< int, 4 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 4u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3,4>;
using j = make_integer_sequence<int,5>;
using i = integer_sequence< int, 0, 1, 2, 3, 4 >;
using j = make_integer_sequence< int, 5 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 5u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<4, i>::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3,4,5>;
using j = make_integer_sequence<int,6>;
using i = integer_sequence< int, 0, 1, 2, 3, 4, 5 >;
using j = make_integer_sequence< int, 6 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 6u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<4, i>::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<5, i>::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3,4,5,6>;
using j = make_integer_sequence<int,7>;
using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6 >;
using j = make_integer_sequence< int, 7 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 7u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<4, i>::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<5, i>::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<6, i>::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3,4,5,6,7>;
using j = make_integer_sequence<int,8>;
using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6, 7 >;
using j = make_integer_sequence< int, 8 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 8u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<4, i>::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<5, i>::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<6, i>::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<7, i>::value == 7, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 7, i >::value == 7, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at(7, i{}) == 7, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 7, i{} ) == 7, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3,4,5,6,7,8>;
using j = make_integer_sequence<int,9>;
using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6, 7, 8 >;
using j = make_integer_sequence< int, 9 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 9u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<4, i>::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<5, i>::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<6, i>::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<7, i>::value == 7, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<8, i>::value == 8, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 7, i >::value == 7, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 8, i >::value == 8, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at(7, i{}) == 7, "Error: at(unsigned, integer_sequence)" );
static_assert( at(8, i{}) == 8, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 7, i{} ) == 7, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 8, i{} ) == 8, "Error: at(unsigned, integer_sequence)" );
}
{
using i = integer_sequence<int,0,1,2,3,4,5,6,7,8,9>;
using j = make_integer_sequence<int,10>;
using i = integer_sequence< int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 >;
using j = make_integer_sequence< int, 10 >;
static_assert( std::is_same<i,j>::value, "Error: make_integer_sequence" );
static_assert( std::is_same< i, j >::value, "Error: make_integer_sequence" );
static_assert( i::size() == 10u, "Error: integer_sequence.size()" );
static_assert( integer_sequence_at<0, i>::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<1, i>::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<2, i>::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<3, i>::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<4, i>::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<5, i>::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<6, i>::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<7, i>::value == 7, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<8, i>::value == 8, "Error: integer_sequence_at" );
static_assert( integer_sequence_at<9, i>::value == 9, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 0, i >::value == 0, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 1, i >::value == 1, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 2, i >::value == 2, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 3, i >::value == 3, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 4, i >::value == 4, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 5, i >::value == 5, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 6, i >::value == 6, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 7, i >::value == 7, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 8, i >::value == 8, "Error: integer_sequence_at" );
static_assert( integer_sequence_at< 9, i >::value == 9, "Error: integer_sequence_at" );
static_assert( at(0, i{}) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at(1, i{}) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at(2, i{}) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at(3, i{}) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at(4, i{}) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at(5, i{}) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at(6, i{}) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at(7, i{}) == 7, "Error: at(unsigned, integer_sequence)" );
static_assert( at(8, i{}) == 8, "Error: at(unsigned, integer_sequence)" );
static_assert( at(9, i{}) == 9, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 0, i{} ) == 0, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 1, i{} ) == 1, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 2, i{} ) == 2, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 3, i{} ) == 3, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 4, i{} ) == 4, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 5, i{} ) == 5, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 6, i{} ) == 6, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 7, i{} ) == 7, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 8, i{} ) == 8, "Error: at(unsigned, integer_sequence)" );
static_assert( at( 9, i{} ) == 9, "Error: at(unsigned, integer_sequence)" );
}
{
using i = make_integer_sequence<int, 5>;
using r = reverse_integer_sequence<i>;
using gr = integer_sequence<int, 4, 3, 2, 1, 0>;
using i = make_integer_sequence< int, 5 >;
using r = reverse_integer_sequence< i >;
using gr = integer_sequence< int, 4, 3, 2, 1, 0 >;
static_assert( std::is_same<r,gr>::value, "Error: reverse_integer_sequence" );
static_assert( std::is_same< r, gr >::value, "Error: reverse_integer_sequence" );
}
{
using s = make_integer_sequence<int,10>;
using e = exclusive_scan_integer_sequence<s>;
using i = inclusive_scan_integer_sequence<s>;
using s = make_integer_sequence< int, 10 >;
using e = exclusive_scan_integer_sequence< s >;
using i = inclusive_scan_integer_sequence< s >;
using ge = integer_sequence<int, 0, 0, 1, 3, 6, 10, 15, 21, 28, 36>;
using gi = integer_sequence<int, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45>;
using ge = integer_sequence< int, 0, 0, 1, 3, 6, 10, 15, 21, 28, 36 >;
using gi = integer_sequence< int, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45 >;
static_assert( e::value == 45, "Error: scan value");
static_assert( i::value == 45, "Error: scan value");
static_assert( e::value == 45, "Error: scan value" );
static_assert( i::value == 45, "Error: scan value" );
static_assert( std::is_same< e::type, ge >::value, "Error: exclusive_scan");
static_assert( std::is_same< i::type, gi >::value, "Error: inclusive_scan");
static_assert( std::is_same< e::type, ge >::value, "Error: exclusive_scan" );
static_assert( std::is_same< i::type, gi >::value, "Error: inclusive_scan" );
}
}
} // namespace Test