Implement the non-execution policy versions of `reduce` and `transform_reduce` for C++17

[mclow.lists]

Summary

There are versions of reduce and transform_reduce that take an execution policy, and those that do not.
This implements the ones that do not.

[mclow.lists]

include/numeric

98

I don't like adding this dependency; but the standard requires the use of std::plus and std::multiplies

[• wash]

Suppose you have:

struct A {};
struct B {};

A operator+(A, B);

std::vector<B> v;
std::reduce(v.begin(), v.end(), A{});

The implementation in this patch works fine for the above case - as would accumulate, which it is equivalent to. However, reduce requires that "All of binary_op(init, *first), binary_op(*first, init), binary_op(init, init), and binary_op(*first, *first) shall be convertible to T.", as all those operations may be needed for the parallel execution-policy overload of reduce (the requirement applies to the non-execution-policy overload as well).

E.g. in the above example, these operations are also required by reduce, even though the non-parallel implementation does not need them:

A operator+(B, A);
A operator+(A, A);
A operator+(B, B);

Should the non-parallel implementation of reduce static_assert or SFINAE away when these requirements are not met? I think it might be desirable to ensure that if this won't compile:

std::reduce(std::par, v.begin(), v.end(), A{});

Then this will also not compile:

std::reduce(v.begin(), v.end(), A{});

(And the spec seems to suggest this too).

include/numeric

154

In the spec, this overload of reduce is described as equivalent to return reduce(std::forward<ExecutionPolicy>(exec), first, last, typename iterator_traits<ForwardIterator>::value_type{});. The overload that it calls (the three argument version that omits a binary operation) just forwards to the four-argument reduce, adding the plus<>() argument.

Is there a reason you wanted to avoid the extra layer of function call indirection (it should be inlined and optimized away, right)? What you have seems perfectly fine, I'm just curious though.

test/std/numerics/numeric.ops/reduce/reduce_iter_iter.pass.cpp

38

Just to confirm, this should be 0 because the "default" init value is iterator_traits<_InputIterator>::value_type{}, and int{} gives you a determinate result (as opposed to int() which would not), correct?

[• wash]

I think the test reduce_iter_iter_T.pass.cpp can be improved a little bit.

Right now, it:

• Tests that the three argument overload (iterators + init) work correctly when the iterator value type is the same as the init type.
• Tests that the return type of the three argument overload is correct in cases where the iterator value type differs from the init type.

It does not, however, test whether the result is correct when the iterator value type differs from the init type.

I'd suggest:

void
test_different_init_type()
{
    char ca[] = {CHAR_MAX, CHAR_MAX, CHAR_MAX, CHAR_MAX};
    unsigned sa = sizeof(ca) / sizeof(ca[0]);
    test(ca, ca, int{0}, int{0});
    test(ca, ca+1, int{0}, int{CHAR_MAX});
    test(ca, ca+2, int{0}, int{2*CHAR_MAX});
    test(ca, ca+sa, int{0}, int{4*CHAR_MAX});
}

[rsmith]

include/numeric

145

Missing _VSTD::

153

Missing _VSTD::

209

Missing _VSTD::

test/std/numerics/numeric.ops/reduce/reduce_iter_iter.pass.cpp

27

Maybe use _v trait?

28

May as well drop the , "" since this test requires C++17 anyway.

38

int() also gives a determinate result.

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

37

Maybe use decltype(auto) here?

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp

42

You could static_assert this if you make sa const.

[• wash]

For all the transform_ variants, the spec allows the "inner" operation (the transformation)'s return type is not constrained. We should have a test for this.

For example, consider the binary-unary transform_reduce implementation:

template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
transform_reduce(_InputIterator __first, _InputIterator __last, 
                 _Tp __init,  _BinaryOp __b, _UnaryOp __u)
{
    for (; __first != __last; ++__first)
        __init = __b(__init, __u(*__first));
    return __init;
}

The standard says the algorithm requires all of the following expressions be convertible to _Tp:

• __b(__init, __init)
• __b(__init, __u(*__first))
• __b(__u(*__first), __init)
• __b(__u(*__first), __u(*__first))

So, the following code should be allowed:

struct A {};
struct B {};
struct C {};

B unary_op(C);
A binary_op(A, A);
A binary_op(A, B);
A binary_op(B, A);
A binary_op(B, B); 

std::vector<C> v;
std::tranform_reduce(v.begin(), v.end(), A{}, binary_op, unary_op);

Similar cases can be constructed for all the other transform_ overloads.

I'll try to find time later to put together a concrete test for this.

EDIT: Note that for transform_ algorithms, the "inner"operation (e.g. the transform) is never applied to the init value. So it is not necessary for unary_op in the above example to be callable with As.

[• wash]

I think we need a test case like this for all of the transform_*s

struct A {};
struct B {};
struct C {};

B unary_op(C);
B unary_op(A) { assert(false); /* unary op applied to init value! */ }
A binary_op(A, A);
A binary_op(A, B);
A binary_op(B, A);
A binary_op(B, B); 

std::vector<C> v;
std::tranform_reduce(v.begin(), v.end(), A{}, binary_op, unary_op);

The "inner" transform operation should never be applied to the init parameter.

include/numeric

209

In the patch I downloaded from here, the spacing before the return is tabs, not spaces.

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

45

In the patch I downloaded from here, there is a tab right before constexpr.

[mclow.lists]

Should the non-parallel implementation of reduce static_assert or SFINAE away when these requirements are not met?

That may be desirable, but that's not what the standard says.
There's nothing there about "shall not participate in overload resolution".

Requires: in the standard is a requirement on the caller.
Failure to satisfy those requirements is UB - and it can compile, not compile, explode at runtime, give the right answer, whatever.

(Look at copy, say)

[mclow.lists]

Rebased now that D34038 has landed; address Richard and Bryce's comments

[mclow.lists]

include/numeric

154

Nah. Just eager on the copy/paste.

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

37

I copied this formulation from <functional> where we use it all over the place ;-)
(but that's because we support old standards)

include/numeric

     T
     accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);
 
+template<class InputIterator>
+    typename iterator_traits<InputIterator>::value_type
+    reduce(InputIterator first, InputIterator last);  // C++17
+
+template<class InputIterator, class T>
+    T
+    reduce(InputIterator first, InputIterator last, T init);  // C++17
+
+template<class InputIterator, class T, class BinaryOperation>
+    T
+    reduce(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);  // C++17
+
 template <class InputIterator1, class InputIterator2, class T>
     T
     inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init);

     inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
                   T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
 
+
+template<class InputIterator1, class InputIterator2, class T>
+    T
+    transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                     InputIterator2 first2, T init);  // C++17
+                     
+template<class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
+    T
+    transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                     InputIterator2 first2, T init,
+                     BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);  // C++17
+
+template<class InputIterator, class T, class BinaryOperation, class UnaryOperation>
+    T
+    transform_reduce(InputIterator first, InputIterator last, T init,
+                     BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
+
 template <class InputIterator, class OutputIterator>
     OutputIterator
     partial_sum(InputIterator first, InputIterator last, OutputIterator result);

     return __init;
 }
 
+#if _LIBCPP_STD_VER > 14
+template <class _InputIterator, class _Tp, class _BinaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOp __b)
+{
+    for (; __first != __last; ++__first)
+        __init = __b(__init, *__first);
+    return __init;
+}
+
+template <class _InputIterator, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
+{
+    return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>());
+}
+
+template <class _InputIterator>
+inline _LIBCPP_INLINE_VISIBILITY
+typename iterator_traits<_InputIterator>::value_type
+reduce(_InputIterator __first, _InputIterator __last)
+{
+    return _VSTD::reduce(__first, __last, 
+       typename iterator_traits<_InputIterator>::value_type{});
+}
+#endif
+
 template <class _InputIterator1, class _InputIterator2, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp

     return __init;
 }
 
+#if _LIBCPP_STD_VER > 14
+template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+transform_reduce(_InputIterator __first, _InputIterator __last, 
+           _Tp __init,  _BinaryOp __b, _UnaryOp __u)
+{
+    for (; __first != __last; ++__first)
+        __init = __b(__init, __u(*__first));
+    return __init;
+}
+
+template <class _InputIterator1, class _InputIterator2, 
+          class _Tp, class _BinaryOp1, class _BinaryOp2>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
+                 _InputIterator2 __first2, _Tp __init,  _BinaryOp1 __b1, _BinaryOp2 __b2)
+{
+    for (; __first1 != __last1; ++__first1, (void) ++__first2)
+        __init = __b1(__init, __b2(*__first1, *__first2));
+    return __init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1, 
+                 _InputIterator2 __first2, _Tp __init)
+{
+    return _VSTD::transform_reduce(__first1, __last1, __first2, __init, 
+                                   _VSTD::plus<>(), _VSTD::multiplies<>());
+}
+#endif
+
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator

test/std/numerics/numeric.ops/reduce/reduce_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>
+//     typename iterator_traits<InputIterator>::value_type
+//     reduce(InputIterator first, InputIterator last);
+
+#include <numeric>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter, class T>
+void
+test(Iter first, Iter last, T x)
+{
+    static_assert( std::is_same_v<typename std::iterator_traits<decltype(first)>::value_type,
+                                decltype(std::reduce(first, last))> );
+    assert(std::reduce(first, last) == x);
+}
+
+template <class Iter>
+void
+test()
+{
+    int ia[] = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    test(Iter(ia), Iter(ia), 0);
+    test(Iter(ia), Iter(ia+1), 1);
+    test(Iter(ia), Iter(ia+2), 3);
+    test(Iter(ia), Iter(ia+sa), 21);
+}
+
+template <typename T>
+void test_return_type()
+{
+    T *p = nullptr;
+    static_assert( std::is_same_v<T, decltype(std::reduce(p, p))> );
+}
+
+int main()
+{
+    test_return_type<char>();
+    test_return_type<int>();
+    test_return_type<unsigned long>();
+    test_return_type<float>();
+    test_return_type<double>();
+
+    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/std/numerics/numeric.ops/reduce/reduce_iter_iter_T.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 T>
+//   T reduce(InputIterator first, InputIterator last, T init);
+
+#include <numeric>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter, class T>
+void
+test(Iter first, Iter last, T init, T x)
+{
+    static_assert( std::is_same_v<T, decltype(std::reduce(first, last, init))> );
+    assert(std::reduce(first, last, init) == x);
+}
+
+template <class Iter>
+void
+test()
+{
+    int ia[] = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    test(Iter(ia), Iter(ia), 0, 0);
+    test(Iter(ia), Iter(ia), 1, 1);
+    test(Iter(ia), Iter(ia+1), 0, 1);
+    test(Iter(ia), Iter(ia+1), 2, 3);
+    test(Iter(ia), Iter(ia+2), 0, 3);
+    test(Iter(ia), Iter(ia+2), 3, 6);
+    test(Iter(ia), Iter(ia+sa), 0, 21);
+    test(Iter(ia), Iter(ia+sa), 4, 25);
+}
+
+template <typename T, typename Init>
+void test_return_type()
+{
+    T *p = nullptr;
+    static_assert( std::is_same_v<Init, decltype(std::reduce(p, p, Init{}))> );
+}
+
+int main()
+{
+    test_return_type<char, int>();
+    test_return_type<int, int>();
+    test_return_type<int, unsigned long>();
+    test_return_type<float, int>();
+    test_return_type<short, float>();
+    test_return_type<double, char>();
+    test_return_type<char, double>();
+
+    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/std/numerics/numeric.ops/reduce/reduce_iter_iter_T_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 T, class BinaryOperation>
+//   T reduce(InputIterator first, InputIterator last, T init, BinaryOperation op);
+  
+#include <numeric>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter, class T, class Op>
+void
+test(Iter first, Iter last, T init, Op op, T x)
+{
+    static_assert( std::is_same_v<T, decltype(std::reduce(first, last, init, op))>, "" );
+    assert(std::reduce(first, last, init, op) == x);
+}
+
+template <class Iter>
+void
+test()
+{
+    int ia[] = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    test(Iter(ia), Iter(ia), 0, std::plus<>(), 0);
+    test(Iter(ia), Iter(ia), 1, std::multiplies<>(), 1);
+    test(Iter(ia), Iter(ia+1), 0, std::plus<>(), 1);
+    test(Iter(ia), Iter(ia+1), 2, std::multiplies<>(), 2);
+    test(Iter(ia), Iter(ia+2), 0, std::plus<>(), 3);
+    test(Iter(ia), Iter(ia+2), 3, std::multiplies<>(), 6);
+    test(Iter(ia), Iter(ia+sa), 0, std::plus<>(), 21);
+    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), 2880);
+}
+
+template <typename T, typename Init>
+void test_return_type()
+{
+    T *p = nullptr;
+    static_assert( std::is_same_v<Init, decltype(std::reduce(p, p, Init{}, std::plus<>()))>, "" );
+}
+
+int main()
+{
+    test_return_type<char, int>();
+    test_return_type<int, int>();
+    test_return_type<int, unsigned long>();
+    test_return_type<float, int>();
+    test_return_type<short, float>();
+    test_return_type<double, char>();
+    test_return_type<char, double>();
+
+    test<input_iterator<const int*> >();
+    test<forward_iterator<const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+
+//  Make sure the math is done using the correct type
+    {
+    auto v = {1, 2, 3, 4, 5, 6, 7, 8};
+    unsigned res = std::reduce(v.begin(), v.end(), 1U, std::multiplies<>());
+    assert(res == 40320);   // 8! will not fit into a char
+    }
+}

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_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 InputIterator1, class T,
+//           class BinaryOperation, class UnaryOperation>
+//    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+//                       T init, BinaryOperation binary_op, UnaryOperation unary_op);
+//                      
+  
+#include <numeric>
+#include <cassert>
+
+#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 _Tp = void>
+struct twice
+{
+    constexpr const _Tp operator()(const _Tp& __x) const noexcept { return 2 * __x; }
+};
+
+template <>
+struct twice<void>
+{
+    template <class _Tp>
+    constexpr auto operator()(const _Tp& __x) const
+    _NOEXCEPT_(noexcept(2 * __x))
+    -> decltype        (2 * __x)
+        { return        2 * __x; }
+};
+
+template <class Iter1, class T, class BOp, class UOp>
+void
+test(Iter1 first1, Iter1 last1, T init, BOp bOp, UOp uOp, T x)
+{
+    static_assert( std::is_same_v<T, 
+                    decltype(std::transform_reduce(first1, last1, init, bOp, uOp))> );
+    assert(std::transform_reduce(first1, last1, init, bOp, uOp) == x);
+}
+
+template <class Iter>
+void
+test()
+{
+    int ia[]          = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+
+    test(Iter(ia), Iter(ia),    0, std::plus<>(),       identity<>(),       0);
+    test(Iter(ia), Iter(ia),    1, std::multiplies<>(), identity<>(),       1);
+    test(Iter(ia), Iter(ia+1),  0, std::multiplies<>(), identity<>(),       0);
+    test(Iter(ia), Iter(ia+1),  2, std::plus<>(),       identity<>(),       3);
+    test(Iter(ia), Iter(ia+2),  0, std::plus<>(),       identity<>(),       3);
+    test(Iter(ia), Iter(ia+2),  3, std::multiplies<>(), identity<>(),       6);
+    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), identity<>(),    2880);
+    test(Iter(ia), Iter(ia+sa), 4, std::plus<>(),       identity<>(),      25);
+
+    test(Iter(ia), Iter(ia),    0, std::plus<>(),       twice<>(),       0);
+    test(Iter(ia), Iter(ia),    1, std::multiplies<>(), twice<>(),       1);
+    test(Iter(ia), Iter(ia+1),  0, std::multiplies<>(), twice<>(),       0);
+    test(Iter(ia), Iter(ia+1),  2, std::plus<>(),       twice<>(),       4);
+    test(Iter(ia), Iter(ia+2),  0, std::plus<>(),       twice<>(),       6);
+    test(Iter(ia), Iter(ia+2),  3, std::multiplies<>(), twice<>(),      24);
+    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), twice<>(),  184320); // 64 * 2880
+    test(Iter(ia), Iter(ia+sa), 4, std::plus<>(),       twice<>(),      46);
+}
+
+template <typename T, typename Init>
+void test_return_type()
+{
+    T *p = nullptr;
+    static_assert( std::is_same_v<Init, 
+         decltype(std::transform_reduce(p, p, Init{}, std::plus<>(), identity<>()))> );
+}
+
+int main()
+{
+    test_return_type<char, int>();
+    test_return_type<int, int>();
+    test_return_type<int, unsigned long>();
+    test_return_type<float, int>();
+    test_return_type<short, float>();
+    test_return_type<double, char>();
+    test_return_type<char, double>();
+
+//  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*>();
+
+//  Make sure the math is done using the correct type
+    {
+    auto v = {1, 2, 3, 4, 5, 6};
+    unsigned res = std::transform_reduce(v.begin(), v.end(), 1U, std::multiplies<>(), twice<>());
+    assert(res == 46080);   // 6! * 64 will not fit into a char
+    }
+}

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_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 InputIterator1, class InputIterator2, class T>
+//   T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+//                      InputIterator2 first2, T init);
+
+
+#include <numeric>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Iter2, class T>
+void
+test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x)
+{
+    static_assert( std::is_same_v<T, 
+            decltype(std::transform_reduce(first1, last1, first2, init))> );
+    assert(std::transform_reduce(first1, last1, first2, init) == x);
+}
+
+template <class SIter, class UIter>
+void
+test()
+{
+    int ia[]          = {1, 2, 3, 4, 5, 6};
+    unsigned int ua[] = {2, 4, 6, 8, 10,12};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa == sizeof(ua) / sizeof(ua[0]));       // just to be sure
+
+    test(SIter(ia), SIter(ia),    UIter(ua), 0,   0);
+    test(UIter(ua), UIter(ua),    SIter(ia), 1,   1);
+    test(SIter(ia), SIter(ia+1),  UIter(ua), 0,   2);
+    test(UIter(ua), UIter(ua+1),  SIter(ia), 2,   4);
+    test(SIter(ia), SIter(ia+2),  UIter(ua), 0,  10);
+    test(UIter(ua), UIter(ua+2),  SIter(ia), 3,  13);
+    test(SIter(ia), SIter(ia+sa), UIter(ua), 0, 182);
+    test(UIter(ua), UIter(ua+sa), SIter(ia), 4, 186);
+}
+
+template <typename T, typename Init>
+void test_return_type()
+{
+    T *p = nullptr;
+    static_assert( std::is_same_v<Init, 
+                       decltype(std::transform_reduce(p, p, p, Init{}))> );
+}
+
+int main()
+{
+    test_return_type<char, int>();
+    test_return_type<int, int>();
+    test_return_type<int, unsigned long>();
+    test_return_type<float, int>();
+    test_return_type<short, float>();
+    test_return_type<double, char>();
+    test_return_type<char, double>();
+
+//  All the iterator categories
+    test<input_iterator        <const int*>, input_iterator        <const unsigned int*> >();
+    test<input_iterator        <const int*>, forward_iterator      <const unsigned int*> >();
+    test<input_iterator        <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<input_iterator        <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test<forward_iterator      <const int*>, input_iterator        <const unsigned int*> >();
+    test<forward_iterator      <const int*>, forward_iterator      <const unsigned int*> >();
+    test<forward_iterator      <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<forward_iterator      <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test<bidirectional_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test<bidirectional_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+    test<random_access_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test<random_access_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+//  just plain pointers (const vs. non-const, too)
+    test<const int*, const unsigned int *>();
+    test<const int*,       unsigned int *>();
+    test<      int*, const unsigned int *>();
+    test<      int*,       unsigned int *>();
+}

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_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 InputIterator1, class InputIterator2, class T,
+//           class BinaryOperation1, class BinaryOperation2>
+//    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+//                       InputIterator2 first2, T init,
+//                       BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
+//                      
+  
+#include <numeric>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Iter2, class T, class Op1, class Op2>
+void
+test(Iter1 first1, Iter1 last1, Iter2 first2, T init, Op1 op1, Op2 op2, T x)
+{
+    static_assert( std::is_same_v<T, 
+         decltype(std::transform_reduce(first1, last1, first2, init, op1, op2))> );
+    assert(std::transform_reduce(first1, last1, first2, init, op1, op2) == x);
+}
+
+template <class SIter, class UIter>
+void
+test()
+{
+    int ia[]          = {1, 2, 3, 4, 5, 6};
+    unsigned int ua[] = {2, 4, 6, 8, 10,12};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    assert(sa == sizeof(ua) / sizeof(ua[0]));       // just to be sure
+
+    test(SIter(ia), SIter(ia),    UIter(ua), 0, std::plus<>(), std::multiplies<>(),       0);
+    test(UIter(ua), UIter(ua),    SIter(ia), 1, std::multiplies<>(), std::plus<>(),       1);
+    test(SIter(ia), SIter(ia+1),  UIter(ua), 0, std::multiplies<>(), std::plus<>(),       0);
+    test(UIter(ua), UIter(ua+1),  SIter(ia), 2, std::plus<>(), std::multiplies<>(),       4);
+    test(SIter(ia), SIter(ia+2),  UIter(ua), 0, std::plus<>(), std::multiplies<>(),      10);
+    test(UIter(ua), UIter(ua+2),  SIter(ia), 3, std::multiplies<>(), std::plus<>(),      54);
+    test(SIter(ia), SIter(ia+sa), UIter(ua), 4, std::multiplies<>(), std::plus<>(), 2099520);
+    test(UIter(ua), UIter(ua+sa), SIter(ia), 4, std::plus<>(), std::multiplies<>(),     186);
+}
+
+template <typename T, typename Init>
+void test_return_type()
+{
+    T *p = nullptr;
+    static_assert( std::is_same_v<Init, 
+       decltype(std::transform_reduce(p, p, p, Init{}, std::plus<>(), std::multiplies<>()))> );
+}
+
+int main()
+{
+    test_return_type<char, int>();
+    test_return_type<int, int>();
+    test_return_type<int, unsigned long>();
+    test_return_type<float, int>();
+    test_return_type<short, float>();
+    test_return_type<double, char>();
+    test_return_type<char, double>();
+
+//  All the iterator categories
+    test<input_iterator        <const int*>, input_iterator        <const unsigned int*> >();
+    test<input_iterator        <const int*>, forward_iterator      <const unsigned int*> >();
+    test<input_iterator        <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<input_iterator        <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test<forward_iterator      <const int*>, input_iterator        <const unsigned int*> >();
+    test<forward_iterator      <const int*>, forward_iterator      <const unsigned int*> >();
+    test<forward_iterator      <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<forward_iterator      <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test<bidirectional_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test<bidirectional_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+    test<random_access_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test<random_access_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+//  just plain pointers (const vs. non-const, too)
+    test<const int*, const unsigned int *>();
+    test<const int*,       unsigned int *>();
+    test<      int*, const unsigned int *>();
+    test<      int*,       unsigned int *>();
+}