Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add dual-sequence overloads to transform_inclusive_scan() and transform_exclusive_scan() #104

Open
wants to merge 4 commits into
base: develop
Choose a base branch
from
Open

Add dual-sequence overloads to transform_inclusive_scan() and transform_exclusive_scan() #104

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
0cf6fb5
Add constexpr to transform_inclusive_scan()
jgopel Jun 5, 2022
7a9d9df
Add dual-sequence implementation of transform_inclusive_scan()
jgopel Jun 5, 2022
fa6e930
Add constexpr to transform_exclusive_scan()
jgopel Jun 5, 2022
2c5d484
Add dual-sequence implementation of transform_exclusive_scan()
jgopel Jun 5, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
38 changes: 38 additions & 0 deletions include/boost/algorithm/cxx17/transform_exclusive_scan.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,7 @@ namespace boost { namespace algorithm {
/// \note This function is part of the C++17 standard library
template<class InputIterator, class OutputIterator, class T,
class BinaryOperation, class UnaryOperation>
BOOST_CXX14_CONSTEXPR
OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
OutputIterator result, T init,
BinaryOperation bOp, UnaryOperation uOp)
Expand All @@ -57,6 +58,43 @@ OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
return result;
}

/// \fn transform_exclusive_scan ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, ScanOperation scan_op, TransformOperation trans_op, T init )
/// \brief Transforms elements from the input range with uOp and then combines
/// those transformed elements with bOp such that the n-1th element and the nth
/// element are combined. Exclusivity means that the nth element is not
/// included in the nth combination.
/// \return The updated output iterator
///
/// \param first1 The start of the first input sequence
/// \param last1 The end of the first input sequence
/// \param first2 The start of the second input sequence
/// \param result The output iterator to write the results into
/// \param scan_op The operation for combining transformed input elements
/// \param trans_op The operation for transforming pairs of input elements
/// \param init The initial value
template<class InputIterator1, class InputIterator2, class OutputIterator,
class ScanOperation, class TransformOperation, class T>
BOOST_CXX14_CONSTEXPR
OutputIterator transform_exclusive_scan(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2,
OutputIterator result, T init,
ScanOperation scan_op, TransformOperation trans_op)
{
if (first1 != last1)
{
T saved = init;
do
{
init = scan_op(init, trans_op(*first1, *first2));
*result = saved;
saved = init;
++first2;
++result;
} while (++first1 != last1);
}
return result;
}

}} // namespace boost and algorithm

#endif // BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
31 changes: 31 additions & 0 deletions include/boost/algorithm/cxx17/transform_inclusive_scan.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,7 @@ namespace boost { namespace algorithm {
/// \note This function is part of the C++17 standard library
template<class InputIterator, class OutputIterator,
class BinaryOperation, class UnaryOperation, class T>
BOOST_CXX14_CONSTEXPR
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
OutputIterator result,
BinaryOperation bOp, UnaryOperation uOp,
Expand Down Expand Up @@ -68,6 +69,7 @@ OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
/// \note This function is part of the C++17 standard library
template<class InputIterator, class OutputIterator,
class BinaryOperation, class UnaryOperation>
BOOST_CXX14_CONSTEXPR
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
OutputIterator result,
BinaryOperation bOp, UnaryOperation uOp)
Expand All @@ -83,6 +85,35 @@ OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
return result;
}

/// \fn transform_inclusive_scan ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, ScanOperation scan_op, TransformOperation trans_op, T init )
/// \brief Transforms elements from the input ranges with trans_op and then
/// combines those transformed elements with scan_op such that the n-1th element
/// and the nth element are combined. Inclusivity means that the nth element is
/// included in the nth combination. The first value will be used as the init.
/// \return The updated output iterator
///
/// \param first1 The start of the first input sequence
/// \param last1 The end of the first input sequence
/// \param first2 The start of the second input sequence
/// \param result The output iterator to write the results into
/// \param scan_op The operation for combining transformed input elements
/// \param trans_op The operation for transforming pairs of input elements
/// \param init The initial value
template<class InputIterator1, class InputIterator2, class OutputIterator,
class ScanOperation, class TransformOperation, class T>
BOOST_CXX14_CONSTEXPR
OutputIterator transform_inclusive_scan(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2,
OutputIterator result,
ScanOperation scan_op, TransformOperation trans_op,
T init)
{
for (; first1 != last1; ++first1, ++first2, ++result) {
init = scan_op(init, trans_op(*first1, *first2));
*result = init;
}
return result;
}

}} // namespace boost and algorithm

Expand Down
121 changes: 109 additions & 12 deletions test/transform_exclusive_scan_test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,8 @@
#include <vector>
#include <functional>
#include <numeric>
#include <algorithm>
#include <iterator>

#include <boost/config.hpp>
#include <boost/algorithm/cxx11/iota.hpp>
Expand All @@ -27,13 +29,13 @@ int triangle(int n) { return n*(n+1)/2; }
template <class _Tp>
struct identity
{
const _Tp& operator()(const _Tp& __x) const { return __x;}
BOOST_CXX14_CONSTEXPR const _Tp& operator()(const _Tp& __x) const { return __x;}
};


template <class Iter1, class BOp, class UOp, class T, class Iter2>
void
test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
test_single_input(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
{
std::vector<typename std::iterator_traits<Iter1>::value_type> v;
// Test not in-place
Expand All @@ -49,12 +51,42 @@ test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLas
BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
}

template <class Iter1, class Iter2, class ScanOperation, class TransformOperation, class T, class Iter3>
void
test_dual_input(Iter1 first1, Iter1 last1,
Iter2 first2,
ScanOperation scan_op, TransformOperation trans_op,
T init, Iter3 expected_first, Iter3 expected_last)
{
{ // Test not in-place
std::vector<typename std::iterator_traits<Iter3>::value_type> output;
ba::transform_exclusive_scan(first1, last1, first2, std::back_inserter(output), init, scan_op, trans_op);
const typename std::iterator_traits<Iter3>::difference_type result_size = std::distance(expected_first, expected_last);
BOOST_CHECK(result_size >= 0);
BOOST_CHECK(static_cast<std::size_t>(result_size) == output.size());
BOOST_CHECK(std::equal(output.begin(), output.end(), expected_first));
}
{ // Test in-place
std::vector<typename std::iterator_traits<Iter3>::value_type> v(first1, last1);
ba::transform_exclusive_scan(v.begin(), v.end(), first2, v.begin(), init, scan_op, trans_op);
const typename std::iterator_traits<Iter3>::difference_type result_size = std::distance(expected_first, expected_last);
BOOST_CHECK(result_size >= 0);
BOOST_CHECK(static_cast<std::size_t>(result_size) == v.size());
BOOST_CHECK(std::equal(v.begin(), v.end(), expected_first));
}
}

template <class Iter>
void
test()
{
int ia[] = { 1, 3, 5, 7, 9};
int ia1[] = { 1, 3, 5, 7, 9};
int ia2[] = { 2, 4, 6, 8, 10};

const unsigned sa = sizeof(ia1) / sizeof(ia1[0]);
BOOST_CHECK(sa == sizeof(ia2) / sizeof(ia2[0])); // just to be sure

// single input results
const int pResI0[] = { 0, 1, 4, 9, 16}; // with identity
const int mResI0[] = { 0, 0, 0, 0, 0};
const int pResN0[] = { 0, -1, -4, -9, -16}; // with negate
Expand All @@ -63,7 +95,7 @@ test()
const int mResI2[] = { 2, 2, 6, 30, 210};
const int pResN2[] = { 2, 1, -2, -7, -14}; // with negate
const int mResN2[] = { 2, -2, 6, -30, 210};
const unsigned sa = sizeof(ia) / sizeof(ia[0]);

BOOST_CHECK(sa == sizeof(pResI0) / sizeof(pResI0[0])); // just to be sure
BOOST_CHECK(sa == sizeof(mResI0) / sizeof(mResI0[0])); // just to be sure
BOOST_CHECK(sa == sizeof(pResN0) / sizeof(pResN0[0])); // just to be sure
Expand All @@ -73,15 +105,43 @@ test()
BOOST_CHECK(sa == sizeof(pResN2) / sizeof(pResN2[0])); // just to be sure
BOOST_CHECK(sa == sizeof(mResN2) / sizeof(mResN2[0])); // just to be sure

// dual input results
const int pResP0[] = { 0, 3, 10, 21, 36};
const int pResP2[] = { 2, 5, 12, 23, 38};
const int pResM0[] = { 0, -1, -2, -3, -4};
const int pResM2[] = { 2, 1, 0, -1, -2};
const int mResP0[] = { 0, -3, -10, -21, -36};
const int mResP2[] = { 2, -1, -8, -19, -34};
const int mResM0[] = { 0, 1, 2, 3, 4};
const int mResM2[] = { 2, 3, 4, 5, 6};

BOOST_CHECK(sa == sizeof(pResP0) / sizeof(pResP0[0])); // just to be sure
BOOST_CHECK(sa == sizeof(pResP2) / sizeof(pResP2[0])); // just to be sure
BOOST_CHECK(sa == sizeof(pResM0) / sizeof(pResM0[0])); // just to be sure
BOOST_CHECK(sa == sizeof(pResM2) / sizeof(pResM2[0])); // just to be sure
BOOST_CHECK(sa == sizeof(mResP0) / sizeof(mResP0[0])); // just to be sure
BOOST_CHECK(sa == sizeof(mResP2) / sizeof(mResP2[0])); // just to be sure
BOOST_CHECK(sa == sizeof(mResM0) / sizeof(mResM0[0])); // just to be sure
BOOST_CHECK(sa == sizeof(mResM2) / sizeof(mResM2[0])); // just to be sure

for (unsigned int i = 0; i < sa; ++i ) {
test(Iter(ia), Iter(ia + i), std::plus<int>(), identity<int>(), 0, pResI0, pResI0 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(), 0, mResI0, mResI0 + i);
test(Iter(ia), Iter(ia + i), std::plus<int>(), std::negate<int>(), 0, pResN0, pResN0 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), 0, mResN0, mResN0 + i);
test(Iter(ia), Iter(ia + i), std::plus<int>(), identity<int>(), 2, pResI2, pResI2 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(), 2, mResI2, mResI2 + i);
test(Iter(ia), Iter(ia + i), std::plus<int>(), std::negate<int>(), 2, pResN2, pResN2 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), 2, mResN2, mResN2 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::plus<int>(), identity<int>(), 0, pResI0, pResI0 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::multiplies<int>(), identity<int>(), 0, mResI0, mResI0 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::plus<int>(), std::negate<int>(), 0, pResN0, pResN0 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::multiplies<int>(), std::negate<int>(), 0, mResN0, mResN0 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::plus<int>(), identity<int>(), 2, pResI2, pResI2 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::multiplies<int>(), identity<int>(), 2, mResI2, mResI2 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::plus<int>(), std::negate<int>(), 2, pResN2, pResN2 + i);
test_single_input(Iter(ia1), Iter(ia1 + i), std::multiplies<int>(), std::negate<int>(), 2, mResN2, mResN2 + i);

test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::plus<int>(), std::plus<int>(), 0, pResP0, pResP0 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::plus<int>(), std::plus<int>(), 2, pResP2, pResP2 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::plus<int>(), std::minus<int>(), 0, pResM0, pResM0 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::plus<int>(), std::minus<int>(), 2, pResM2, pResM2 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::minus<int>(), std::plus<int>(), 0, mResP0, mResP0 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::minus<int>(), std::plus<int>(), 2, mResP2, mResP2 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::minus<int>(), std::minus<int>(), 0, mResM0, mResM0 + i);
test_dual_input(Iter(ia1), Iter(ia1 + i), Iter(ia2), std::minus<int>(), std::minus<int>(), 2, mResM2, mResM2 + i);
}
}

Expand Down Expand Up @@ -118,6 +178,38 @@ void basic_tests()
}
}

BOOST_CXX14_CONSTEXPR bool constexpr_transform_exclusive_scan_tests() {
typedef random_access_iterator<int*> iterator_t;

const int NUM_ELEMENTS = 3;

bool status = true;
{ // Single input range
int input[NUM_ELEMENTS] = {3, 3, 3};
int output[NUM_ELEMENTS] = {0, 0, 0};
ba::transform_exclusive_scan(
iterator_t(input), iterator_t(input + NUM_ELEMENTS),
iterator_t(output),
30,
std::plus<int>(), identity<int>());
for (size_t i = 0; i < NUM_ELEMENTS; ++i)
status &= (output[i] == 30 + (int)(i * 3));
}
{ // Dual input ranges
int input1[NUM_ELEMENTS] = {3, 3, 3};
int input2[NUM_ELEMENTS] = {1, 1, 1};
int output[NUM_ELEMENTS] = {0, 0, 0};
ba::transform_exclusive_scan(
iterator_t(input1), iterator_t(input1 + NUM_ELEMENTS),
iterator_t(input2),
iterator_t(output),
30,
std::plus<int>(), std::minus<int>());
for (size_t i = 0; i < NUM_ELEMENTS; ++i)
status &= (output[i] == 30 + (int)(i * 2));
}
return status;
}

void test_transform_exclusive_scan_init()
{
Expand All @@ -129,6 +221,11 @@ void test_transform_exclusive_scan_init()
test<random_access_iterator<const int*> >();
test<const int*>();
test< int*>();

{
BOOST_CXX14_CONSTEXPR bool status = constexpr_transform_exclusive_scan_tests();
BOOST_CHECK(status == true);
}
}

BOOST_AUTO_TEST_CASE( test_main )
Expand Down
Loading