mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-07-16 15:14:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename reduct_iterator -> reduce_iterator

Browse source
This commit is contained in:
bolero-MURAKAMI 2015-05-11 10:34:12 +09:00
parent 64ca12a984
commit fc0a1817d5
46 changed files with 1413 additions and 1413 deletions
Download patch file Download diff file Expand all files Collapse all files

32
libs/algorithm/test/adjacent_find.cpp
View file

@ -53,31 +53,31 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -85,31 +85,31 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find( SPROUT_STATIC_CONSTEXPR auto found = sprout::adjacent_find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

32
libs/algorithm/test/all_of.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::less_than<int>(11) testspr::less_than<int>(11)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(11) testspr::less_than<int>(11)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less_than<int>(11) testspr::less_than<int>(11)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less_than<int>(11) testspr::less_than<int>(11)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

16
libs/algorithm/test/all_of_equal.cpp
View file

@ -38,16 +38,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
1 1
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
1 1
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -55,16 +55,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
1 1
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::all_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
1 1
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

32
libs/algorithm/test/any_of.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);

32
libs/algorithm/test/any_of_equal.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
10 10
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
11 11
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
10 10
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
11 11
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
10 10
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
11 11
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
10 10
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::any_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
11 11
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);

16
libs/algorithm/test/binary_search.cpp
View file

@ -39,16 +39,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search( SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
7 7
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search( SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
); );
@ -57,16 +57,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search( SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
7 7
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search( SPROUT_STATIC_CONSTEXPR auto result = sprout::binary_search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
); );

72
libs/algorithm/test/copy.cpp
View file

@ -105,8 +105,8 @@ namespace testspr {
// copy in range [2 .. 8) // copy in range [2 .. 8)
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_input(sprout::begin(arr1) + 2), testspr::reduce_input(sprout::begin(arr1) + 2),
testspr::reduct_input(sprout::begin(arr1) + 8), testspr::reduce_input(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -117,8 +117,8 @@ namespace testspr {
// !!! BUG: sprout::fit::copy implementation requires ForwardIterator // !!! BUG: sprout::fit::copy implementation requires ForwardIterator
// { // {
// SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( // SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
// testspr::reduct_input(sprout::begin(arr1) + 2), // testspr::reduce_input(sprout::begin(arr1) + 2),
// testspr::reduct_input(sprout::begin(arr1) + 8), // testspr::reduce_input(sprout::begin(arr1) + 8),
// arr2 // arr2
// ); // );
// TESTSPR_BOTH_ASSERT(testspr::equal( // TESTSPR_BOTH_ASSERT(testspr::equal(
@ -130,8 +130,8 @@ namespace testspr {
// overrun from output range // overrun from output range
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_input(sprout::begin(arr1) + 2), testspr::reduce_input(sprout::begin(arr1) + 2),
testspr::reduct_input(sprout::begin(arr1) + 8), testspr::reduce_input(sprout::begin(arr1) + 8),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -142,8 +142,8 @@ namespace testspr {
// !!! BUG: sprout::fit::copy implementation requires ForwardIterator // !!! BUG: sprout::fit::copy implementation requires ForwardIterator
// { // {
// SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( // SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
// testspr::reduct_input(sprout::begin(arr1) + 2), // testspr::reduce_input(sprout::begin(arr1) + 2),
// testspr::reduct_input(sprout::begin(arr1) + 8), // testspr::reduce_input(sprout::begin(arr1) + 8),
// arr3 // arr3
// ); // );
// TESTSPR_BOTH_ASSERT(testspr::equal( // TESTSPR_BOTH_ASSERT(testspr::equal(
@ -155,8 +155,8 @@ namespace testspr {
// to sub range // to sub range
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_input(sprout::begin(arr1) + 2), testspr::reduce_input(sprout::begin(arr1) + 2),
testspr::reduct_input(sprout::begin(arr1) + 8), testspr::reduce_input(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -171,8 +171,8 @@ namespace testspr {
// !!! BUG: sprout::fit::copy implementation requires ForwardIterator // !!! BUG: sprout::fit::copy implementation requires ForwardIterator
// { // {
// SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( // SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
// testspr::reduct_input(sprout::begin(arr1) + 2), // testspr::reduce_input(sprout::begin(arr1) + 2),
// testspr::reduct_input(sprout::begin(arr1) + 8), // testspr::reduce_input(sprout::begin(arr1) + 8),
// sprout::sub(arr2, 2, 8) // sprout::sub(arr2, 2, 8)
// ); // );
// TESTSPR_BOTH_ASSERT(testspr::equal( // TESTSPR_BOTH_ASSERT(testspr::equal(
@ -188,8 +188,8 @@ namespace testspr {
// copy in range [2 .. 8) // copy in range [2 .. 8)
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -199,8 +199,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -212,8 +212,8 @@ namespace testspr {
// overrun from output range // overrun from output range
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -223,8 +223,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -236,8 +236,8 @@ namespace testspr {
// to sub range // to sub range
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -251,8 +251,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -268,8 +268,8 @@ namespace testspr {
// copy in range [2 .. 8) // copy in range [2 .. 8)
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_random_access(sprout::begin(arr1) + 2), testspr::reduce_random_access(sprout::begin(arr1) + 2),
testspr::reduct_random_access(sprout::begin(arr1) + 8), testspr::reduce_random_access(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -279,8 +279,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
testspr::reduct_random_access(sprout::begin(arr1) + 2), testspr::reduce_random_access(sprout::begin(arr1) + 2),
testspr::reduct_random_access(sprout::begin(arr1) + 8), testspr::reduce_random_access(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -292,8 +292,8 @@ namespace testspr {
// overrun from output range // overrun from output range
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_random_access(sprout::begin(arr1) + 2), testspr::reduce_random_access(sprout::begin(arr1) + 2),
testspr::reduct_random_access(sprout::begin(arr1) + 8), testspr::reduce_random_access(sprout::begin(arr1) + 8),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -303,8 +303,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
testspr::reduct_random_access(sprout::begin(arr1) + 2), testspr::reduce_random_access(sprout::begin(arr1) + 2),
testspr::reduct_random_access(sprout::begin(arr1) + 8), testspr::reduce_random_access(sprout::begin(arr1) + 8),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -316,8 +316,8 @@ namespace testspr {
// to sub range // to sub range
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::copy(
testspr::reduct_random_access(sprout::begin(arr1) + 2), testspr::reduce_random_access(sprout::begin(arr1) + 2),
testspr::reduct_random_access(sprout::begin(arr1) + 8), testspr::reduce_random_access(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -331,8 +331,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy( SPROUT_STATIC_CONSTEXPR auto copied = sprout::fit::copy(
testspr::reduct_random_access(sprout::begin(arr1) + 2), testspr::reduce_random_access(sprout::begin(arr1) + 2),
testspr::reduct_random_access(sprout::begin(arr1) + 8), testspr::reduce_random_access(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(

32
libs/algorithm/test/count.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
5 5
); );
TESTSPR_BOTH_ASSERT(result == 4); TESTSPR_BOTH_ASSERT(result == 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
11 11
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
5 5
); );
TESTSPR_BOTH_ASSERT(result == 2); TESTSPR_BOTH_ASSERT(result == 2);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
11 11
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
5 5
); );
TESTSPR_BOTH_ASSERT(result == 4); TESTSPR_BOTH_ASSERT(result == 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
11 11
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
5 5
); );
TESTSPR_BOTH_ASSERT(result == 2); TESTSPR_BOTH_ASSERT(result == 2);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count( SPROUT_STATIC_CONSTEXPR auto result = sprout::count(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
11 11
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);

36
libs/algorithm/test/count_if.cpp
View file

@ -45,8 +45,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(8) testspr::less_than<int>(8)
); );
TESTSPR_BOTH_ASSERT(result == 5); TESTSPR_BOTH_ASSERT(result == 5);
@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result == 5); TESTSPR_BOTH_ASSERT(result == 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::less_than<int>(8) testspr::less_than<int>(8)
); );
TESTSPR_BOTH_ASSERT(result == 7); TESTSPR_BOTH_ASSERT(result == 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result == 3); TESTSPR_BOTH_ASSERT(result == 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(8) testspr::less_than<int>(8)
); );
TESTSPR_BOTH_ASSERT(result == 5); TESTSPR_BOTH_ASSERT(result == 5);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result == 5); TESTSPR_BOTH_ASSERT(result == 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less_than<int>(8) testspr::less_than<int>(8)
); );
TESTSPR_BOTH_ASSERT(result == 7); TESTSPR_BOTH_ASSERT(result == 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result == 3); TESTSPR_BOTH_ASSERT(result == 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if( SPROUT_STATIC_CONSTEXPR auto result = sprout::count_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less_than<int>(8) testspr::less_than<int>(8)
); );
TESTSPR_BOTH_ASSERT(result == 5); TESTSPR_BOTH_ASSERT(result == 5);

222
libs/algorithm/test/equal.cpp
View file

@ -93,69 +93,69 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)) testspr::reduce_input(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)) testspr::reduce_input(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)) testspr::reduce_input(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)) testspr::reduce_input(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -163,69 +163,69 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)) testspr::reduce_random_access(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)) testspr::reduce_random_access(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -311,76 +311,76 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2)) testspr::reduce_input(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::begin(arr3) + 5) testspr::reduce_input(sprout::begin(arr3) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::begin(arr3) + 5), testspr::reduce_input(sprout::begin(arr3) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -388,77 +388,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::begin(arr3) + 5) testspr::reduce_random_access(sprout::begin(arr3) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::begin(arr3) + 5), testspr::reduce_random_access(sprout::begin(arr3) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

16
libs/algorithm/test/equal_range.cpp
View file

@ -44,8 +44,8 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range( SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
7 7
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 6); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 6);
@ -54,8 +54,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range( SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
); );
@ -66,8 +66,8 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range( SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
7 7
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 6); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 6);
@ -76,8 +76,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range( SPROUT_STATIC_CONSTEXPR auto found = sprout::equal_range(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
); );

32
libs/algorithm/test/find.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
8 8
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
11 11
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
8 8
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
11 11
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
8 8
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
11 11
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
8 8
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find( SPROUT_STATIC_CONSTEXPR auto found = sprout::find(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
11 11
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

96
libs/algorithm/test/find_end.cpp
View file

@ -101,77 +101,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 2); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 2);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 2); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 2);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -179,40 +179,40 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 2); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 2);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_end(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

128
libs/algorithm/test/find_first_of.cpp
View file

@ -101,77 +101,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -179,77 +179,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_first_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

32
libs/algorithm/test/find_if.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(7) testspr::greater_than<int>(7)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(7) testspr::greater_than<int>(7)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(7) testspr::greater_than<int>(7)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(7) testspr::greater_than<int>(7)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

32
libs/algorithm/test/find_if_not.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::less_than<int>(8) testspr::less_than<int>(8)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::less_than<int>(11) testspr::less_than<int>(11)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(8) testspr::less_than<int>(8)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(11) testspr::less_than<int>(11)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less_than<int>(8) testspr::less_than<int>(8)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less_than<int>(11) testspr::less_than<int>(11)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less_than<int>(8) testspr::less_than<int>(8)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not( SPROUT_STATIC_CONSTEXPR auto found = sprout::find_if_not(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less_than<int>(11) testspr::less_than<int>(11)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

128
libs/algorithm/test/includes.cpp
View file

@ -101,77 +101,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
@ -179,77 +179,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::includes( SPROUT_STATIC_CONSTEXPR auto result = sprout::includes(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);

16
libs/algorithm/test/is_decreasing.cpp
View file

@ -36,30 +36,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_decreasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }

32
libs/algorithm/test/is_heap.cpp
View file

@ -83,60 +83,60 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_heap(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

32
libs/algorithm/test/is_heap_until.cpp
View file

@ -83,60 +83,60 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 7); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_heap_until(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr2) + 5);

16
libs/algorithm/test/is_increasing.cpp
View file

@ -36,30 +36,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_increasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }

32
libs/algorithm/test/is_partitioned.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::is_odd<int>() testspr::is_odd<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_partitioned(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less_than<int>(6) testspr::less_than<int>(6)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

224
libs/algorithm/test/is_permutation.cpp
View file

@ -93,69 +93,69 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)) testspr::reduce_forward(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)) testspr::reduce_forward(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)) testspr::reduce_forward(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)) testspr::reduce_forward(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -163,69 +163,69 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)) testspr::reduce_random_access(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)) testspr::reduce_random_access(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -311,77 +311,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::begin(arr2) + 5) testspr::reduce_forward(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::begin(arr3) + 5) testspr::reduce_forward(sprout::begin(arr3) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::begin(arr2) + 5), testspr::reduce_forward(sprout::begin(arr2) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::begin(arr3) + 5), testspr::reduce_forward(sprout::begin(arr3) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -389,77 +389,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::begin(arr3) + 5) testspr::reduce_random_access(sprout::begin(arr3) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_permutation(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::begin(arr3) + 5), testspr::reduce_random_access(sprout::begin(arr3) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

32
libs/algorithm/test/is_sorted.cpp
View file

@ -52,30 +52,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -83,30 +83,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_sorted(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

32
libs/algorithm/test/is_sorted_until.cpp
View file

@ -52,30 +52,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -83,30 +83,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until( SPROUT_STATIC_CONSTEXPR auto found = sprout::is_sorted_until(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

32
libs/algorithm/test/is_strictly_decreasing.cpp
View file

@ -51,58 +51,58 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::begin(arr2) + 5) testspr::reduce_forward(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_decreasing(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }

32
libs/algorithm/test/is_strictly_increasing.cpp
View file

@ -51,58 +51,58 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::begin(arr2) + 5) testspr::reduce_forward(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing( SPROUT_STATIC_CONSTEXPR auto result = sprout::is_strictly_increasing(
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }

224
libs/algorithm/test/lexicographical_compare.cpp
View file

@ -158,133 +158,133 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)) testspr::reduce_input(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)) testspr::reduce_input(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2) + 5) testspr::reduce_input(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)), testspr::reduce_input(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)), testspr::reduce_input(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2) + 5), testspr::reduce_input(sprout::begin(arr2) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
@ -292,133 +292,133 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)) testspr::reduce_random_access(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)) testspr::reduce_random_access(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)), testspr::reduce_random_access(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)), testspr::reduce_random_access(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);

16
libs/algorithm/test/lower_bound.cpp
View file

@ -39,16 +39,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
7 7
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 6); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 6);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
).base(); ).base();
@ -57,16 +57,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
7 7
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 6); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 6);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::lower_bound(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
).base(); ).base();

32
libs/algorithm/test/max_element.cpp
View file

@ -52,30 +52,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4);
@ -83,30 +83,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 8);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::max_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 4);

32
libs/algorithm/test/min_element.cpp
View file

@ -52,30 +52,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3);
@ -83,30 +83,30 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 9);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::min_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result == sprout::begin(arr1) + 3);

32
libs/algorithm/test/minmax_element.cpp
View file

@ -56,24 +56,24 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)) testspr::reduce_forward(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9);
TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 8); TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 8);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5) testspr::reduce_forward(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3);
TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9);
@ -81,8 +81,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3);
@ -91,24 +91,24 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)) testspr::reduce_random_access(sprout::end(arr1))
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9);
TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 8); TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 8);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5) testspr::reduce_random_access(sprout::begin(arr1) + 5)
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3);
TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 4); TESTSPR_BOTH_ASSERT(result.second.base() == sprout::begin(arr1) + 4);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 9);
@ -116,8 +116,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element( SPROUT_STATIC_CONSTEXPR auto result = sprout::minmax_element(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(result.first.base() == sprout::begin(arr1) + 3);

224
libs/algorithm/test/mismatch.cpp
View file

@ -101,36 +101,36 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)) testspr::reduce_input(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)) testspr::reduce_input(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)) testspr::reduce_input(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)) testspr::reduce_input(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
@ -138,9 +138,9 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
@ -148,9 +148,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -158,9 +158,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
@ -168,9 +168,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -179,36 +179,36 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)) testspr::reduce_random_access(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)) testspr::reduce_random_access(sprout::begin(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)) testspr::reduce_random_access(sprout::begin(arr3))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
@ -216,9 +216,9 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
@ -226,9 +226,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -236,9 +236,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
@ -246,9 +246,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -343,40 +343,40 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2) + 5) testspr::reduce_input(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::begin(arr2) + 5) testspr::reduce_input(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
@ -384,10 +384,10 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
@ -395,10 +395,10 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -406,10 +406,10 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2) + 5), testspr::reduce_input(sprout::begin(arr2) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
@ -417,10 +417,10 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::begin(arr2) + 5), testspr::reduce_input(sprout::begin(arr2) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -429,40 +429,40 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 7);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2)); TESTSPR_BOTH_ASSERT(found.second.base() == sprout::begin(arr2));
@ -470,10 +470,10 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 7);
@ -481,10 +481,10 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));
@ -492,10 +492,10 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1) + 5);
@ -503,10 +503,10 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch( SPROUT_STATIC_CONSTEXPR auto found = sprout::mismatch(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::equal_to<int>() testspr::equal_to<int>()
); );
TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1)); TESTSPR_BOTH_ASSERT(found.first.base() == sprout::begin(arr1));

32
libs/algorithm/test/none_of.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(5) testspr::greater_than<int>(5)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(10) testspr::greater_than<int>(10)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

32
libs/algorithm/test/none_of_equal.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
10 10
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
11 11
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
10 10
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
11 11
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
10 10
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
11 11
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
10 10
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::none_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
11 11
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);

32
libs/algorithm/test/one_of.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(4) testspr::greater_than<int>(4)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::greater_than<int>(9) testspr::greater_than<int>(9)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(4) testspr::greater_than<int>(4)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::greater_than<int>(9) testspr::greater_than<int>(9)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(4) testspr::greater_than<int>(4)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::greater_than<int>(9) testspr::greater_than<int>(9)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(4) testspr::greater_than<int>(4)
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::greater_than<int>(9) testspr::greater_than<int>(9)
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);

32
libs/algorithm/test/one_of_equal.cpp
View file

@ -54,32 +54,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
5 5
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
10 10
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
5 5
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
10 10
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
@ -87,32 +87,32 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
5 5
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
10 10
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
5 5
); );
TESTSPR_BOTH_ASSERT(result); TESTSPR_BOTH_ASSERT(result);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal( SPROUT_STATIC_CONSTEXPR auto result = sprout::one_of_equal(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
10 10
); );
TESTSPR_BOTH_ASSERT(!result); TESTSPR_BOTH_ASSERT(!result);

16
libs/algorithm/test/partition_point.cpp
View file

@ -38,16 +38,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point( SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::is_odd<int>() testspr::is_odd<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point( SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::is_odd<int>() testspr::is_odd<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -55,16 +55,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point( SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::is_odd<int>() testspr::is_odd<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point( SPROUT_STATIC_CONSTEXPR auto found = sprout::partition_point(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::is_odd<int>() testspr::is_odd<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

36
libs/algorithm/test/rotate_copy.cpp
View file

@ -111,9 +111,9 @@ namespace testspr {
// rotate in range [2 .. 8) // rotate in range [2 .. 8)
{ {
SPROUT_STATIC_CONSTEXPR auto rotated = sprout::rotate_copy( SPROUT_STATIC_CONSTEXPR auto rotated = sprout::rotate_copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 4), testspr::reduce_forward(sprout::begin(arr1) + 4),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -123,9 +123,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto rotated = sprout::fit::rotate_copy( SPROUT_STATIC_CONSTEXPR auto rotated = sprout::fit::rotate_copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 4), testspr::reduce_forward(sprout::begin(arr1) + 4),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
arr2 arr2
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -137,9 +137,9 @@ namespace testspr {
// overrun from output range // overrun from output range
{ {
SPROUT_STATIC_CONSTEXPR auto rotated = sprout::rotate_copy( SPROUT_STATIC_CONSTEXPR auto rotated = sprout::rotate_copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 4), testspr::reduce_forward(sprout::begin(arr1) + 4),
testspr::reduct_forward(sprout::begin(arr1) + 7), testspr::reduce_forward(sprout::begin(arr1) + 7),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -149,9 +149,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto rotated = sprout::fit::rotate_copy( SPROUT_STATIC_CONSTEXPR auto rotated = sprout::fit::rotate_copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 4), testspr::reduce_forward(sprout::begin(arr1) + 4),
testspr::reduct_forward(sprout::begin(arr1) + 7), testspr::reduce_forward(sprout::begin(arr1) + 7),
arr3 arr3
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -163,9 +163,9 @@ namespace testspr {
// to sub range // to sub range
{ {
SPROUT_STATIC_CONSTEXPR auto rotated = sprout::rotate_copy( SPROUT_STATIC_CONSTEXPR auto rotated = sprout::rotate_copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 4), testspr::reduce_forward(sprout::begin(arr1) + 4),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(
@ -179,9 +179,9 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto rotated = sprout::fit::rotate_copy( SPROUT_STATIC_CONSTEXPR auto rotated = sprout::fit::rotate_copy(
testspr::reduct_forward(sprout::begin(arr1) + 2), testspr::reduce_forward(sprout::begin(arr1) + 2),
testspr::reduct_forward(sprout::begin(arr1) + 4), testspr::reduce_forward(sprout::begin(arr1) + 4),
testspr::reduct_forward(sprout::begin(arr1) + 8), testspr::reduce_forward(sprout::begin(arr1) + 8),
sprout::sub(arr2, 2, 8) sprout::sub(arr2, 2, 8)
); );
TESTSPR_BOTH_ASSERT(testspr::equal( TESTSPR_BOTH_ASSERT(testspr::equal(

128
libs/algorithm/test/search.cpp
View file

@ -101,77 +101,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)) testspr::reduce_forward(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)) testspr::reduce_forward(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr2)), testspr::reduce_forward(sprout::begin(arr2)),
testspr::reduct_forward(sprout::end(arr2)), testspr::reduce_forward(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
testspr::reduct_forward(sprout::begin(arr3)), testspr::reduce_forward(sprout::begin(arr3)),
testspr::reduct_forward(sprout::end(arr3)), testspr::reduce_forward(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
@ -179,77 +179,77 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 3);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::end(arr1)); TESTSPR_BOTH_ASSERT(found == sprout::end(arr1));
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search( SPROUT_STATIC_CONSTEXPR auto found = sprout::search(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::equal_to<int>() testspr::equal_to<int>()
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 5);

64
libs/algorithm/test/search_n.cpp
View file

@ -99,8 +99,8 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
2, 2,
5 5
).base(); ).base();
@ -108,8 +108,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
4, 4,
5 5
).base(); ).base();
@ -117,8 +117,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
2, 2,
5 5
).base(); ).base();
@ -126,8 +126,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
4, 4,
5 5
).base(); ).base();
@ -136,8 +136,8 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
2, 2,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -146,8 +146,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
4, 4,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -156,8 +156,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
2, 2,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -166,8 +166,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
4, 4,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -177,8 +177,8 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
2, 2,
5 5
).base(); ).base();
@ -186,8 +186,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
4, 4,
5 5
).base(); ).base();
@ -195,8 +195,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
2, 2,
5 5
).base(); ).base();
@ -204,8 +204,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
4, 4,
5 5
).base(); ).base();
@ -214,8 +214,8 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
2, 2,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -224,8 +224,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
4, 4,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -234,8 +234,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
2, 2,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()
@ -244,8 +244,8 @@ namespace testspr {
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n( SPROUT_STATIC_CONSTEXPR auto found = sprout::search_n(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
4, 4,
5, 5,
testspr::equal_to<int>() testspr::equal_to<int>()

224
libs/algorithm/test/tristate_lexicographical_compare.cpp
View file

@ -158,133 +158,133 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)) testspr::reduce_input(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)) testspr::reduce_input(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)) testspr::reduce_input(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)) testspr::reduce_input(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2) + 5) testspr::reduce_input(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)), testspr::reduce_input(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::end(arr2)), testspr::reduce_input(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr3)), testspr::reduce_input(sprout::begin(arr3)),
testspr::reduct_input(sprout::end(arr3)), testspr::reduce_input(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::begin(arr1) + 5), testspr::reduce_input(sprout::begin(arr1) + 5),
testspr::reduct_input(sprout::begin(arr4)), testspr::reduce_input(sprout::begin(arr4)),
testspr::reduct_input(sprout::end(arr4)), testspr::reduce_input(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_input(sprout::begin(arr1)), testspr::reduce_input(sprout::begin(arr1)),
testspr::reduct_input(sprout::end(arr1)), testspr::reduce_input(sprout::end(arr1)),
testspr::reduct_input(sprout::begin(arr2)), testspr::reduce_input(sprout::begin(arr2)),
testspr::reduct_input(sprout::begin(arr2) + 5), testspr::reduce_input(sprout::begin(arr2) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
@ -292,133 +292,133 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)) testspr::reduce_random_access(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)) testspr::reduce_random_access(sprout::end(arr2))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)) testspr::reduce_random_access(sprout::end(arr3))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)) testspr::reduce_random_access(sprout::end(arr4))
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5) testspr::reduce_random_access(sprout::begin(arr2) + 5)
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result == 0); TESTSPR_BOTH_ASSERT(result == 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)), testspr::reduce_random_access(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::end(arr2)), testspr::reduce_random_access(sprout::end(arr2)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr3)), testspr::reduce_random_access(sprout::begin(arr3)),
testspr::reduct_random_access(sprout::end(arr3)), testspr::reduce_random_access(sprout::end(arr3)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
testspr::reduct_random_access(sprout::begin(arr4)), testspr::reduce_random_access(sprout::begin(arr4)),
testspr::reduct_random_access(sprout::end(arr4)), testspr::reduce_random_access(sprout::end(arr4)),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result < 0); TESTSPR_BOTH_ASSERT(result < 0);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare( SPROUT_STATIC_CONSTEXPR auto result = sprout::tristate_lexicographical_compare(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
testspr::reduct_random_access(sprout::begin(arr2)), testspr::reduce_random_access(sprout::begin(arr2)),
testspr::reduct_random_access(sprout::begin(arr2) + 5), testspr::reduce_random_access(sprout::begin(arr2) + 5),
testspr::less<int>() testspr::less<int>()
); );
TESTSPR_BOTH_ASSERT(result > 0); TESTSPR_BOTH_ASSERT(result > 0);

16
libs/algorithm/test/upper_bound.cpp
View file

@ -39,16 +39,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::end(arr1)), testspr::reduce_forward(sprout::end(arr1)),
7 7
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 9);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound(
testspr::reduct_forward(sprout::begin(arr1)), testspr::reduce_forward(sprout::begin(arr1)),
testspr::reduct_forward(sprout::begin(arr1) + 5), testspr::reduce_forward(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
).base(); ).base();
@ -57,16 +57,16 @@ namespace testspr {
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::end(arr1)), testspr::reduce_random_access(sprout::end(arr1)),
7 7
).base(); ).base();
TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 9); TESTSPR_BOTH_ASSERT(found == sprout::begin(arr1) + 9);
} }
{ {
SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound( SPROUT_STATIC_CONSTEXPR auto found = sprout::upper_bound(
testspr::reduct_random_access(sprout::begin(arr1)), testspr::reduce_random_access(sprout::begin(arr1)),
testspr::reduct_random_access(sprout::begin(arr1) + 5), testspr::reduce_random_access(sprout::begin(arr1) + 5),
7, 7,
testspr::less<int>() testspr::less<int>()
).base(); ).base();

2
libs/string/test/string.cpp
View file

@ -83,7 +83,7 @@ namespace testspr {
TESTSPR_BOTH_ASSERT(s1 == "ffffff"); TESTSPR_BOTH_ASSERT(s1 == "ffffff");
} }
{ {
SPROUT_STATIC_CONSTEXPR auto s1 = sprout::string_t<10>::type(testspr::reduct_input(str1.begin()), testspr::reduct_input(str1.begin() + 6)); SPROUT_STATIC_CONSTEXPR auto s1 = sprout::string_t<10>::type(testspr::reduce_input(str1.begin()), testspr::reduce_input(str1.begin() + 6));
TESTSPR_BOTH_ASSERT(s1 == "foobar"); TESTSPR_BOTH_ASSERT(s1 == "foobar");
} }
{ {

150
testspr/iterator.hpp
View file

@ -20,10 +20,10 @@
namespace testspr { namespace testspr {
// //
// reduct_iterator // reduce_iterator
// //
template<typename Iterator, typename Category = typename std::iterator_traits<Iterator>::iterator_category> template<typename Iterator, typename Category = typename std::iterator_traits<Iterator>::iterator_category>
class reduct_iterator class reduce_iterator
: public std::iterator< : public std::iterator<
Category, Category,
typename std::iterator_traits<Iterator>::value_type, typename std::iterator_traits<Iterator>::value_type,
@ -42,20 +42,20 @@ namespace testspr {
protected: protected:
iterator_type current; iterator_type current;
public: public:
SPROUT_CONSTEXPR reduct_iterator() SPROUT_CONSTEXPR reduce_iterator()
: current() : current()
{} {}
reduct_iterator(reduct_iterator const& other) = default; reduce_iterator(reduce_iterator const& other) = default;
explicit SPROUT_CONSTEXPR reduct_iterator(iterator_type it) explicit SPROUT_CONSTEXPR reduce_iterator(iterator_type it)
: current(it) : current(it)
{} {}
template<typename U, typename V, typename sprout::enabler_if<sprout::is_convert_constructible<Iterator, U>::value>::type = sprout::enabler> template<typename U, typename V, typename sprout::enabler_if<sprout::is_convert_constructible<Iterator, U>::value>::type = sprout::enabler>
SPROUT_CONSTEXPR reduct_iterator(reduct_iterator<U, V> const& it) SPROUT_CONSTEXPR reduce_iterator(reduce_iterator<U, V> const& it)
: current(it.base()) : current(it.base())
{} {}
template<typename U, typename V, typename sprout::enabler_if<sprout::is_convert_constructible<Iterator, U>::value>::type = sprout::enabler> template<typename U, typename V, typename sprout::enabler_if<sprout::is_convert_constructible<Iterator, U>::value>::type = sprout::enabler>
SPROUT_CXX14_CONSTEXPR reduct_iterator& operator=(reduct_iterator<U, V> const& it) { SPROUT_CXX14_CONSTEXPR reduce_iterator& operator=(reduce_iterator<U, V> const& it) {
reduct_iterator temp(it); reduce_iterator temp(it);
temp.swap(*this); temp.swap(*this);
return *this; return *this;
} }
@ -68,50 +68,50 @@ namespace testspr {
SPROUT_CONSTEXPR pointer operator->() const { SPROUT_CONSTEXPR pointer operator->() const {
return &*current; return &*current;
} }
SPROUT_CXX14_CONSTEXPR reduct_iterator& operator++() { SPROUT_CXX14_CONSTEXPR reduce_iterator& operator++() {
++current; ++current;
return *this; return *this;
} }
SPROUT_CXX14_CONSTEXPR reduct_iterator operator++(int) { SPROUT_CXX14_CONSTEXPR reduce_iterator operator++(int) {
reduct_iterator result(*this); reduce_iterator result(*this);
++current; ++current;
return result; return result;
} }
SPROUT_CXX14_CONSTEXPR reduct_iterator& operator--() { SPROUT_CXX14_CONSTEXPR reduce_iterator& operator--() {
--current; --current;
return *this; return *this;
} }
SPROUT_CXX14_CONSTEXPR reduct_iterator operator--(int) { SPROUT_CXX14_CONSTEXPR reduce_iterator operator--(int) {
reduct_iterator temp(*this); reduce_iterator temp(*this);
--current; --current;
return temp; return temp;
} }
SPROUT_CONSTEXPR reduct_iterator operator+(difference_type n) const { SPROUT_CONSTEXPR reduce_iterator operator+(difference_type n) const {
return reduct_iterator(current + n); return reduce_iterator(current + n);
} }
SPROUT_CONSTEXPR reduct_iterator operator-(difference_type n) const { SPROUT_CONSTEXPR reduce_iterator operator-(difference_type n) const {
return reduct_iterator(current - n); return reduce_iterator(current - n);
} }
SPROUT_CXX14_CONSTEXPR reduct_iterator& operator+=(difference_type n) { SPROUT_CXX14_CONSTEXPR reduce_iterator& operator+=(difference_type n) {
reduct_iterator temp(current + n); reduce_iterator temp(current + n);
temp.swap(*this); temp.swap(*this);
return *this; return *this;
} }
SPROUT_CXX14_CONSTEXPR reduct_iterator& operator-=(difference_type n) { SPROUT_CXX14_CONSTEXPR reduce_iterator& operator-=(difference_type n) {
reduct_iterator temp(current - n); reduce_iterator temp(current - n);
temp.swap(*this); temp.swap(*this);
return *this; return *this;
} }
SPROUT_CONSTEXPR reference operator[](difference_type n) const { SPROUT_CONSTEXPR reference operator[](difference_type n) const {
return current[n]; return current[n];
} }
SPROUT_CONSTEXPR reduct_iterator next() const { SPROUT_CONSTEXPR reduce_iterator next() const {
return reduct_iterator(sprout::next(current)); return reduce_iterator(sprout::next(current));
} }
SPROUT_CONSTEXPR reduct_iterator prev() const { SPROUT_CONSTEXPR reduce_iterator prev() const {
return reduct_iterator(sprout::prev(current)); return reduce_iterator(sprout::prev(current));
} }
SPROUT_CXX14_CONSTEXPR void swap(reduct_iterator& other) SPROUT_CXX14_CONSTEXPR void swap(reduce_iterator& other)
SPROUT_NOEXCEPT_IF( SPROUT_NOEXCEPT_IF(
SPROUT_NOEXCEPT_EXPR(swap(current, other.current)) SPROUT_NOEXCEPT_EXPR(swap(current, other.current))
) )
@ -123,88 +123,88 @@ namespace testspr {
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR bool inline SPROUT_CONSTEXPR bool
operator==(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator==(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return lhs.base() == rhs.base(); return lhs.base() == rhs.base();
} }
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR bool inline SPROUT_CONSTEXPR bool
operator!=(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator!=(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return !(lhs == rhs); return !(lhs == rhs);
} }
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR bool inline SPROUT_CONSTEXPR bool
operator<(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator<(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return lhs.base() < rhs.base(); return lhs.base() < rhs.base();
} }
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR bool inline SPROUT_CONSTEXPR bool
operator>(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator>(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return rhs < lhs; return rhs < lhs;
} }
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR bool inline SPROUT_CONSTEXPR bool
operator<=(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator<=(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return !(rhs < lhs); return !(rhs < lhs);
} }
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR bool inline SPROUT_CONSTEXPR bool
operator>=(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator>=(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return !(lhs < rhs); return !(lhs < rhs);
} }
template<typename Iterator1, typename Category1, typename Iterator2, typename Category2> template<typename Iterator1, typename Category1, typename Iterator2, typename Category2>
inline SPROUT_CONSTEXPR decltype(std::declval<Iterator1>() - std::declval<Iterator2>()) inline SPROUT_CONSTEXPR decltype(std::declval<Iterator1>() - std::declval<Iterator2>())
operator-(testspr::reduct_iterator<Iterator1, Category1> const& lhs, testspr::reduct_iterator<Iterator2, Category2> const& rhs) { operator-(testspr::reduce_iterator<Iterator1, Category1> const& lhs, testspr::reduce_iterator<Iterator2, Category2> const& rhs) {
return lhs.base() - rhs.base(); return lhs.base() - rhs.base();
} }
template<typename Iterator, typename Category> template<typename Iterator, typename Category>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, Category> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, Category>
operator+( operator+(
typename testspr::reduct_iterator<Iterator, Category>::difference_type n, typename testspr::reduce_iterator<Iterator, Category>::difference_type n,
testspr::reduct_iterator<Iterator, Category> const& it testspr::reduce_iterator<Iterator, Category> const& it
) )
{ {
return it + n; return it + n;
} }
// //
// make_reduct_iterator // make_reduce_iterator
// //
template<typename Iterator> template<typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator>
make_reduct_iterator(Iterator it) { make_reduce_iterator(Iterator it) {
return testspr::reduct_iterator<Iterator>(it); return testspr::reduce_iterator<Iterator>(it);
} }
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, Category> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, Category>
make_reduct_iterator(Iterator it) { make_reduce_iterator(Iterator it) {
return testspr::reduct_iterator<Iterator, Category>(it); return testspr::reduce_iterator<Iterator, Category>(it);
} }
// //
// reduct_input // reduce_input
// reduct_forward // reduce_forward
// reduct_bidirectional // reduce_bidirectional
// reduct_random_access // reduce_random_access
// //
template<typename Iterator> template<typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, std::input_iterator_tag> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, std::input_iterator_tag>
reduct_input(Iterator it) { reduce_input(Iterator it) {
return testspr::reduct_iterator<Iterator, std::input_iterator_tag>(it); return testspr::reduce_iterator<Iterator, std::input_iterator_tag>(it);
} }
template<typename Iterator> template<typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, std::forward_iterator_tag> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, std::forward_iterator_tag>
reduct_forward(Iterator it) { reduce_forward(Iterator it) {
return testspr::reduct_iterator<Iterator, std::forward_iterator_tag>(it); return testspr::reduce_iterator<Iterator, std::forward_iterator_tag>(it);
} }
template<typename Iterator> template<typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, std::bidirectional_iterator_tag> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, std::bidirectional_iterator_tag>
reduct_bidirectional(Iterator it) { reduce_bidirectional(Iterator it) {
return testspr::reduct_iterator<Iterator, std::bidirectional_iterator_tag>(it); return testspr::reduce_iterator<Iterator, std::bidirectional_iterator_tag>(it);
} }
template<typename Iterator> template<typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, std::random_access_iterator_tag> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, std::random_access_iterator_tag>
reduct_random_access(Iterator it) { reduce_random_access(Iterator it) {
return testspr::reduct_iterator<Iterator, std::random_access_iterator_tag>(it); return testspr::reduce_iterator<Iterator, std::random_access_iterator_tag>(it);
} }
// //
@ -212,7 +212,7 @@ namespace testspr {
// //
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CXX14_CONSTEXPR void inline SPROUT_CXX14_CONSTEXPR void
swap(testspr::reduct_iterator<Iterator, Category>& lhs, testspr::reduct_iterator<Iterator, Category>& rhs) swap(testspr::reduce_iterator<Iterator, Category>& lhs, testspr::reduce_iterator<Iterator, Category>& rhs)
SPROUT_NOEXCEPT_IF_EXPR(lhs.swap(rhs)) SPROUT_NOEXCEPT_IF_EXPR(lhs.swap(rhs))
{ {
lhs.swap(rhs); lhs.swap(rhs);
@ -222,8 +222,8 @@ namespace testspr {
// iterator_distance // iterator_distance
// //
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CONSTEXPR typename std::iterator_traits<testspr::reduct_iterator<Iterator, Category> >::difference_type inline SPROUT_CONSTEXPR typename std::iterator_traits<testspr::reduce_iterator<Iterator, Category> >::difference_type
iterator_distance(testspr::reduct_iterator<Iterator, Category> first, testspr::reduct_iterator<Iterator, Category> last) { iterator_distance(testspr::reduce_iterator<Iterator, Category> first, testspr::reduce_iterator<Iterator, Category> last) {
return sprout::distance(first.base(), last.base()); return sprout::distance(first.base(), last.base());
} }
@ -231,36 +231,36 @@ namespace testspr {
// iterator_next // iterator_next
// //
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, Category> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, Category>
iterator_next(testspr::reduct_iterator<Iterator, Category> const& it) { iterator_next(testspr::reduce_iterator<Iterator, Category> const& it) {
return it.next(); return it.next();
} }
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, Category> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, Category>
iterator_next( iterator_next(
testspr::reduct_iterator<Iterator, Category> const& it, testspr::reduce_iterator<Iterator, Category> const& it,
typename testspr::reduct_iterator<Iterator, Category>::difference_type n typename testspr::reduce_iterator<Iterator, Category>::difference_type n
) )
{ {
return testspr::reduct_iterator<Iterator, Category>(sprout::next(it.base(), n)); return testspr::reduce_iterator<Iterator, Category>(sprout::next(it.base(), n));
} }
// //
// iterator_prev // iterator_prev
// //
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, Category> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, Category>
iterator_prev(testspr::reduct_iterator<Iterator, Category> const& it) { iterator_prev(testspr::reduce_iterator<Iterator, Category> const& it) {
return it.prev(); return it.prev();
} }
template<typename Category, typename Iterator> template<typename Category, typename Iterator>
inline SPROUT_CONSTEXPR testspr::reduct_iterator<Iterator, Category> inline SPROUT_CONSTEXPR testspr::reduce_iterator<Iterator, Category>
iterator_prev( iterator_prev(
testspr::reduct_iterator<Iterator, Category> const& it, testspr::reduce_iterator<Iterator, Category> const& it,
typename testspr::reduct_iterator<Iterator, Category>::difference_type n typename testspr::reduce_iterator<Iterator, Category>::difference_type n
) )
{ {
return testspr::reduct_iterator<Iterator, Category>(sprout::next(it.base(), n)); return testspr::reduce_iterator<Iterator, Category>(sprout::next(it.base(), n));
} }
} // namespace testspr } // namespace testspr

36
testspr/range.hpp
View file

@ -25,17 +25,17 @@ namespace testspr {
// //
// reducted_range // reducted_range
// //
template<typename Range, typename Category = typename testspr::reduct_iterator<typename sprout::container_traits<Range>::iterator>::iterator_category> template<typename Range, typename Category = typename testspr::reduce_iterator<typename sprout::container_traits<Range>::iterator>::iterator_category>
class reducted_range class reducted_range
: public sprout::adaptors::detail::adapted_range_default< : public sprout::adaptors::detail::adapted_range_default<
Range, Range,
testspr::reduct_iterator<typename sprout::container_traits<Range>::iterator, Category> testspr::reduce_iterator<typename sprout::container_traits<Range>::iterator, Category>
> >
{ {
public: public:
typedef sprout::adaptors::detail::adapted_range_default< typedef sprout::adaptors::detail::adapted_range_default<
Range, Range,
testspr::reduct_iterator<typename sprout::container_traits<Range>::iterator, Category> testspr::reduce_iterator<typename sprout::container_traits<Range>::iterator, Category>
> base_type; > base_type;
typedef typename base_type::range_type range_type; typedef typename base_type::range_type range_type;
typedef typename base_type::iterator iterator; typedef typename base_type::iterator iterator;
@ -51,13 +51,13 @@ namespace testspr {
}; };
// //
// make_reduct_range // make_reduce_range
// //
template<typename Range> template<typename Range>
inline SPROUT_CONSTEXPR testspr::range::reducted_range< inline SPROUT_CONSTEXPR testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
> >
make_reduct_range(Range&& rng) { make_reduce_range(Range&& rng) {
return testspr::range::reducted_range< return testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
>( >(
@ -69,7 +69,7 @@ namespace testspr {
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type, typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type,
Category Category
> >
make_reduct_range(Range&& rng) { make_reduce_range(Range&& rng) {
return testspr::range::reducted_range< return testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type, typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type,
Category Category
@ -79,42 +79,42 @@ namespace testspr {
} }
// //
// reduct_input // reduce_input
// reduct_forward // reduce_forward
// reduct_bidirectional // reduce_bidirectional
// reduct_random_access // reduce_random_access
// //
template<typename Range> template<typename Range>
inline SPROUT_CONSTEXPR testspr::range::reducted_range< inline SPROUT_CONSTEXPR testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type, typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type,
std::input_iterator_tag std::input_iterator_tag
> >
reduct_input(Range&& rng) { reduce_input(Range&& rng) {
return testspr::range::make_reduct_range<std::input_iterator_tag>(SPROUT_FORWARD(Range, rng)); return testspr::range::make_reduce_range<std::input_iterator_tag>(SPROUT_FORWARD(Range, rng));
} }
template<typename Range> template<typename Range>
inline SPROUT_CONSTEXPR testspr::range::reducted_range< inline SPROUT_CONSTEXPR testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type, typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type,
std::forward_iterator_tag std::forward_iterator_tag
> >
reduct_forward(Range&& rng) { reduce_forward(Range&& rng) {
return testspr::range::make_reduct_range<std::forward_iterator_tag>(SPROUT_FORWARD(Range, rng)); return testspr::range::make_reduce_range<std::forward_iterator_tag>(SPROUT_FORWARD(Range, rng));
} }
template<typename Range> template<typename Range>
inline SPROUT_CONSTEXPR testspr::range::reducted_range< inline SPROUT_CONSTEXPR testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type, typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type,
std::bidirectional_iterator_tag std::bidirectional_iterator_tag
> >
reduct_bidirectional(Range&& rng) { reduce_bidirectional(Range&& rng) {
return testspr::range::make_reduct_range<std::bidirectional_iterator_tag>(SPROUT_FORWARD(Range, rng)); return testspr::range::make_reduce_range<std::bidirectional_iterator_tag>(SPROUT_FORWARD(Range, rng));
} }
template<typename Range> template<typename Range>
inline SPROUT_CONSTEXPR testspr::range::reducted_range< inline SPROUT_CONSTEXPR testspr::range::reducted_range<
typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type, typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type,
std::random_access_iterator_tag std::random_access_iterator_tag
> >
reduct_random_access(Range&& rng) { reduce_random_access(Range&& rng) {
return testspr::range::make_reduct_range<std::random_access_iterator_tag>(SPROUT_FORWARD(Range, rng)); return testspr::range::make_reduce_range<std::random_access_iterator_tag>(SPROUT_FORWARD(Range, rng));
} }
} // namespace range } // namespace range
} // namespace testspr } // namespace testspr