1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: libcpp-has-no-incomplete-pstl
// <numeric>
// template<class ExecutionPolicy,
// class ForwardIterator1, class ForwardIterator2, class T>
// T transform_reduce(ExecutionPolicy&& exec,
// ForwardIterator1 first1, ForwardIterator1 last1,
// ForwardIterator2 first2,
// T init);
//
// template<class ExecutionPolicy,
// class ForwardIterator1, class ForwardIterator2, class T,
// class BinaryOperation1, class BinaryOperation2>
// T transform_reduce(ExecutionPolicy&& exec,
// ForwardIterator1 first1, ForwardIterator1 last1,
// ForwardIterator2 first2,
// T init,
// BinaryOperation1 binary_op1,
// BinaryOperation2 binary_op2);
#include <numeric>
#include <vector>
#include "MoveOnly.h"
#include "test_execution_policies.h"
#include "test_iterators.h"
#include "test_macros.h"
#include "type_algorithms.h"
template <class T>
struct constructible_from {
T v_;
explicit constructible_from(T v) : v_(v) {}
friend constructible_from operator+(constructible_from lhs, constructible_from rhs) {
return constructible_from{lhs.get() + rhs.get()};
}
T get() const { return v_; }
};
template <class Iter1, class Iter2, class ValueT>
struct Test {
template <class Policy>
void operator()(Policy&& policy) {
for (const auto& pair : {std::pair{0, 34}, {1, 40}, {2, 48}, {100, 10534}, {350, 124284}}) {
auto [size, expected] = pair;
std::vector<int> a(size);
std::vector<int> b(size);
for (int i = 0; i != size; ++i) {
a[i] = i + 1;
b[i] = i + 4;
}
decltype(auto) ret = std::transform_reduce(
policy,
Iter1(std::data(a)),
Iter1(std::data(a) + std::size(a)),
Iter2(std::data(b)),
ValueT(34),
std::plus{},
[](ValueT i, ValueT j) { return i + j + 1; });
static_assert(std::is_same_v<decltype(ret), ValueT>);
assert(ret == expected);
}
for (const auto& pair : {std::pair{0, 34}, {1, 30}, {2, 24}, {100, 313134}, {350, 14045884}}) {
auto [size, expected] = pair;
std::vector<int> a(size);
std::vector<int> b(size);
for (int i = 0; i != size; ++i) {
a[i] = i + 1;
b[i] = i - 4;
}
decltype(auto) ret = std::transform_reduce(
policy, Iter1(std::data(a)), Iter1(std::data(a) + std::size(a)), Iter2(std::data(b)), 34);
static_assert(std::is_same_v<decltype(ret), int>);
assert(ret == expected);
}
{
int a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int b[] = {8, 7, 6, 5, 4, 3, 2, 1};
auto ret = std::transform_reduce(
policy,
Iter1(std::begin(a)),
Iter1(std::end(a)),
Iter2(std::begin(b)),
constructible_from<int>{0},
std::plus{},
[](int i, int j) { return constructible_from<int>{i + j}; });
assert(ret.get() == 72);
}
}
};
int main(int, char**) {
types::for_each(
types::forward_iterator_list<int*>{}, types::apply_type_identity{[](auto v) {
using Iter2 = typename decltype(v)::type;
types::for_each(
types::forward_iterator_list<int*>{}, types::apply_type_identity{[](auto v2) {
using Iter1 = typename decltype(v2)::type;
types::for_each(
types::type_list<int, MoveOnly>{},
TestIteratorWithPolicies<types::partial_instantiation<Test, Iter1, Iter2>::template apply>{});
}});
}});
return 0;
}
|
