Implement inclusive_scan and transform_inclusive_scan

[mclow.lists]

Summary

Like D33997, this implements the non-parallel versions of these algorithms

D33997 implemented reduce and transform_reduce, this adds inclusive_scan and transform_inclusive_scan.

There will be another patch that adds exclusive_scan and transform_exclusive_scan

[mclow.lists]

Re-reading this, I may have implemented exclusive_scan instead of inclusive_scan here.

[mclow.lists]

I don't think that this is a correct implementation. Also, I need tests for when the result overwrites the source.
As they say .. I'll be back :-)

[• wash]

Minor note: there's a mix of tabs and spaces in this diff.

[• wash]

So, the inclusive_scan overloads that do not take an init parameter should be equivalent to partial_sum for the non-parallel version.

[• wash]

Here's partial_sum:

template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
            _BinaryOperation __binary_op)
{
    if (__first != __last)
    {
        typename iterator_traits<_InputIterator>::value_type __t(*__first);
        *__result = __t;
        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
        {
            __t = __binary_op(__t, *__first);
            *__result = __t;
        }
    }
    return __result;
}

And here's the inclusive_scan that should be equivalent to that partial_sum:

template <class _InputIterator, class _OutputIterator, class _BinaryOp>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last, 
               _OutputIterator __result, _BinaryOp __b)
{
    if (__first != __last) {
        typename iterator_traits<_InputIterator>::value_type __init = *__first++;
        return inclusive_scan(__first, __last, __result, __b, __init);
     }
    
    return __result;
}

The inclusive_scan that it forwards to is:

template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator 
inclusive_scan(_InputIterator __first, _InputIterator __last, 
               _OutputIterator __result, _BinaryOp __b,  _Tp __init)
{
    *__result++ = __init;
    for (; __first != __last; ++__first) {
        __init = __b(__init, *__first);
        *__result++ = __init;
     }

    return __result;
}

Inlining it, we get:

template <class _InputIterator, class _OutputIterator, class _BinaryOp>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last, 
               _OutputIterator __result, _BinaryOp __b)
{
    if (__first != __last) {
        typename iterator_traits<_InputIterator>::value_type __init = *__first++;
        *__result++ = __init;

        for (; __first != __last; ++__first) {
            __init = __b(__init, *__first);
            *__result++ = __init;
        }
     }
    
    return __result;
}

That looks equivalent to the partial_sum implementation above, so I think it is correct.

include/numeric

     OutputIterator
     partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);
 
+template<class InputIterator, class OutputIterator>
+    OutputIterator
+    inclusive_scan(InputIterator first, InputIterator last, OutputIterator result); // C++17
+
+template<class InputIterator, class OutputIterator, class BinaryOperation>
+    OutputIterator
+    inclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result, BinaryOperation binary_op); // C++17
+
+template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
+    OutputIterator
+    inclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result, BinaryOperation binary_op, T init); // C++17
+
+template<class InputIterator, class OutputIterator, 
+         class BinaryOperation, class UnaryOperation>
+  OutputIterator
+  transform_inclusive_scan(InputIterator first, InputIterator last,
+                           OutputIterator result,
+                           BinaryOperation binary_op, UnaryOperation unary_op); // C++17
+
+template<class InputIterator, class OutputIterator,
+         class BinaryOperation, class UnaryOperation, class T>
+    OutputIterator
+    transform_inclusive_scan(InputIterator first, InputIterator last,
+                             OutputIterator result,
+                             BinaryOperation binary_op,UnaryOperation unary_op,
+                             T init);   // C++17
+
 template <class InputIterator, class OutputIterator>
     OutputIterator
     adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);

 #include <__config>
 #include <iterator>
 #include <limits> // for numeric_limits
+#include <functional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

     return __result;
 }
 
+#if _LIBCPP_STD_VER > 14
+template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator 
+inclusive_scan(_InputIterator __first, _InputIterator __last, 
+               _OutputIterator __result, _BinaryOp __b,  _Tp __init)
+{
+    *__result++ = __init;
+    for (; __first != __last; ++__first) {
+        __init = __b(__init, *__first);
+        *__result++ = __init;
+        }
+
+    return __result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+inclusive_scan(_InputIterator __first, _InputIterator __last, 
+                               _OutputIterator __result, _BinaryOp __b)
+{
+    if (__first != __last) {
+        typename iterator_traits<_InputIterator>::value_type __init = *__first++;
+        return inclusive_scan(__first, __last, __result, __b, __init);
+        }
+    
+    return __result;
+}
+
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
+inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+    return inclusive_scan(__first, __last, __result, _VSTD::plus<>());
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+transform_inclusive_scan(_InputIterator __first, _InputIterator __last, 
+                         _OutputIterator __result, 
+                         _BinaryOp __b, _UnaryOp __u, _Tp __init)
+{
+    *__result++ = __init;
+    for (; __first != __last; ++__first) {
+        __init = __b(__init, __u(*__first));
+        *__result++ = __init;
+        }
+
+    return __result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+transform_inclusive_scan(_InputIterator __first, _InputIterator __last, 
+                               _OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
+{
+    if (__first != __last) {
+        typename iterator_traits<_InputIterator>::value_type __init = __u(*__first++);
+        return transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
+        }
+    
+    return __result;
+}
+#endif
+
+template <class _InputIterator, class _OutputIterator>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
 adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     if (__first != __last)

test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_iter_iter_iter.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, C++14
+
+// template<class InputIterator, class OutputIterator>
+//     OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+//                                   OutputIterator result);
+// 
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Iter2>
+void
+test(Iter1 first, Iter1 last, Iter2 rFirst, Iter2 rLast)
+{
+  std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+  std::inclusive_scan(first, last, std::back_inserter(v));
+  assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]   = {1, 3,  5,   7,   9};
+    const int pRes[] = {1, 4,  9,  16,  25};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
+
+  for (unsigned int i = 0; i < sa; ++i )
+      test(Iter(ia), Iter(ia + i), pRes, pRes + i);
+}
+
+int main()
+{
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}

test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_iter_iter_iter_op.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, C++14
+
+// template<class InputIterator, class OutputIterator, class BinaryOperation>
+//     OutputIterator
+//     inclusive_scan(InputIterator first, InputIterator last,
+//                    OutputIterator result, BinaryOperation binary_op); // C++17
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Op, class Iter2>
+void
+test(Iter1 first, Iter1 last, Op op, Iter2 rFirst, Iter2 rLast)
+{
+  std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+  std::inclusive_scan(first, last, std::back_inserter(v), op);
+  assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]   = {1, 3,  5,   7,   9};
+    const int pRes[] = {1, 4,  9,  16,  25};
+    const int mRes[] = {1, 3, 15, 105, 945};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
+    assert(sa == sizeof(mRes) / sizeof(mRes[0]));       // just to be sure
+
+  for (unsigned int i = 0; i < sa; ++i ) {
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       pRes, pRes + i);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), mRes, mRes + i);
+      }
+}
+
+int main()
+{
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}

test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_iter_iter_iter_op_init.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, C++14
+
+// template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
+//     OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+//                                   OutputIterator result, BinaryOperation binary_op, T init);
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Op, class T, class Iter2>
+void
+test(Iter1 first, Iter1 last, Op op, T init, Iter2 rFirst, Iter2 rLast)
+{
+  std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+  std::inclusive_scan(first, last, std::back_inserter(v), op, init);
+  assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]    = {1, 3, 5,  7,   9};
+    const int pRes0[] = {0, 1, 4,  9,  16,    25};
+    const int mRes0[] = {0, 0, 0,  0,   0,     0};
+    const int pRes2[] = {2, 3, 6, 11,  18,    27};
+    const int mRes2[] = {2, 2, 6, 30, 210,  1890};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa + 1 == sizeof(pRes0) / sizeof(pRes0[0]));       // just to be sure
+    assert(sa + 1 == sizeof(mRes0) / sizeof(mRes0[0]));       // just to be sure
+    assert(sa + 1 == sizeof(pRes2) / sizeof(pRes2[0]));       // just to be sure
+    assert(sa + 1 == sizeof(mRes2) / sizeof(mRes2[0]));       // just to be sure
+
+  for (unsigned int i = 0; i < sa; ++i ) {
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       0, pRes0, pRes0 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), 0, mRes0, mRes0 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       2, pRes2, pRes2 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), 2, mRes2, mRes2 + i + 1);
+      }
+}
+
+int main()
+{
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}

test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_iter_iter_iter_bop_uop.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, C++14
+
+// template<class InputIterator, class OutputIterator,
+//          class BinaryOperation, class UnaryOperation>
+//   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+//                                           OutputIterator result,
+//                                           BinaryOperation binary_op,
+//                                           UnaryOperation unary_op);
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+// #include <iostream>
+
+#include "test_iterators.h"
+
+template <class _Tp = void>
+struct identity : std::unary_function<_Tp, _Tp>
+{
+    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+};
+
+template <>
+struct identity<void>
+{
+    template <class _Tp>
+    constexpr auto operator()(_Tp&& __x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
+    -> decltype        (_VSTD::forward<_Tp>(__x))
+        { return        _VSTD::forward<_Tp>(__x); }
+};
+
+template <class Iter1, class BOp, class UOp, class Iter2>
+void
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, Iter2 rFirst, Iter2 rLast)
+{
+  std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+  std::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop);
+//  std::cout << v.size() << " vs " << std::distance(rFirst, rLast) << std::endl;
+//  std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
+//  std::cout << std::endl;
+  assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]    = { 1,  3,   5,   7,    9};
+    const int pResI[] = { 1,  4,   9,  16,   25};    // with identity
+    const int mResI[] = { 1,  3,  15, 105,  945};    
+    const int pResN[] = {-1, -4,  -9, -16,  -25};    // with negate
+    const int mResN[] = {-1,  3, -15, 105, -945};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa == sizeof(pResI) / sizeof(pResI[0]));       // just to be sure
+    assert(sa == sizeof(mResI) / sizeof(mResI[0]));       // just to be sure
+    assert(sa == sizeof(pResN) / sizeof(pResN[0]));       // just to be sure
+    assert(sa == sizeof(mResN) / sizeof(mResN[0]));       // just to be sure
+
+  for (unsigned int i = 0; i < sa; ++i ) {
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    pResI, pResI + i);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    mResI, mResI + i);
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), pResN, pResN + i);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), mResN, mResN + i);
+      }
+}
+
+int main()
+{
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}

test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_iter_iter_iter_bop_uop_init.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, C++14
+
+// template<class InputIterator, class OutputIterator,
+//          class BinaryOperation, class UnaryOperation, class T>
+//   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+//                                           OutputIterator result,
+//                                           BinaryOperation binary_op,
+//                                           UnaryOperation unary_op, T init);
+
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+// #include <iostream>
+
+#include "test_iterators.h"
+
+template <class _Tp = void>
+struct identity : std::unary_function<_Tp, _Tp>
+{
+    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+};
+
+template <>
+struct identity<void>
+{
+    template <class _Tp>
+    constexpr auto operator()(_Tp&& __x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
+    -> decltype        (_VSTD::forward<_Tp>(__x))
+        { return        _VSTD::forward<_Tp>(__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)
+{
+  std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+  std::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop, init);
+//  std::cout << v.size() << " vs " << std::distance(rFirst, rLast) << std::endl;
+//  std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
+//  std::cout << std::endl;
+  assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]     = {     1,  3,   5,   7,     9};
+    const int pResI0[] = { 0,  1,  4,   9,  16,    25};    // with identity
+    const int mResI0[] = { 0,  0,  0,   0,   0,     0};    
+    const int pResN0[] = { 0, -1, -4,  -9, -16,   -25};    // with negate
+    const int mResN0[] = { 0,  0,  0,   0,   0,     0};
+    const int pResI2[] = { 2,  3,  6,  11,  18,    27};    // with identity
+    const int mResI2[] = { 2,  2,  6,  30, 210,  1890};    
+    const int pResN2[] = { 2,  1, -2,  -7, -14,   -23};    // with negate
+    const int mResN2[] = { 2, -2,  6, -30, 210, -1890};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa + 1 == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
+    assert(sa + 1 == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
+    assert(sa + 1 == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
+    assert(sa + 1 == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
+    assert(sa + 1 == sizeof(pResI2) / sizeof(pResI2[0]));       // just to be sure
+    assert(sa + 1 == sizeof(mResI2) / sizeof(mResI2[0]));       // just to be sure
+    assert(sa + 1 == sizeof(pResN2) / sizeof(pResN2[0]));       // just to be sure
+    assert(sa + 1 == sizeof(mResN2) / sizeof(mResN2[0]));       // just to be sure
+
+  for (unsigned int i = 0; i < sa; ++i ) {
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    0, pResI0, pResI0 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    0, mResI0, mResI0 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 0, pResN0, pResN0 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    2, pResI2, pResI2 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    2, mResI2, mResI2 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 2, pResN2, pResN2 + i + 1);
+      test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i + 1);
+      }
+}
+
+int main()
+{
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}