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
125
126
127
128
129
130
131
132
133
134
135
136
|
// -*- C++ -*-
//===-- transform_reduce.pass.cpp -----------------------------------------===//
//
// 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++98, c++03, c++11, c++14
#include "support/pstl_test_config.h"
#include <execution>
#include <numeric>
#include "support/utils.h"
using namespace TestUtils;
// Equal for all types
template <typename T>
static bool
Equal(T x, T y)
{
return x == y;
}
// Functor for xor-operation for modeling binary operations in inner_product
class XOR
{
public:
template <typename T>
T
operator()(const T& left, const T& right) const
{
return left ^ right;
}
};
// Model of User-defined class
class MyClass
{
public:
int32_t my_field;
MyClass() { my_field = 0; }
MyClass(int32_t in) { my_field = in; }
MyClass(const MyClass& in) { my_field = in.my_field; }
friend MyClass
operator+(const MyClass& x, const MyClass& y)
{
return MyClass(x.my_field + y.my_field);
}
friend MyClass
operator-(const MyClass& x)
{
return MyClass(-x.my_field);
}
friend MyClass operator*(const MyClass& x, const MyClass& y) { return MyClass(x.my_field * y.my_field); }
bool
operator==(const MyClass& in)
{
return my_field == in.my_field;
}
};
template <typename T>
void
CheckResults(const T& expected, const T& in)
{
EXPECT_TRUE(Equal(expected, in), "wrong result of transform_reduce");
}
// We need to check correctness only for "int" (for example) except cases
// if we have "floating-point type"-specialization
void
CheckResults(const float32_t&, const float32_t&)
{
}
// Test for different types and operations with different iterators
struct test_transform_reduce
{
template <typename Policy, typename InputIterator1, typename InputIterator2, typename T, typename BinaryOperation1,
typename BinaryOperation2, typename UnaryOp>
void
operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2,
T init, BinaryOperation1 opB1, BinaryOperation2 opB2, UnaryOp opU)
{
auto expectedB = std::inner_product(first1, last1, first2, init, opB1, opB2);
auto expectedU = transform_reduce_serial(first1, last1, init, opB1, opU);
T resRA = std::transform_reduce(exec, first1, last1, first2, init, opB1, opB2);
CheckResults(expectedB, resRA);
resRA = std::transform_reduce(exec, first1, last1, init, opB1, opU);
CheckResults(expectedU, resRA);
}
};
template <typename T, typename BinaryOperation1, typename BinaryOperation2, typename UnaryOp, typename Initializer>
void
test_by_type(T init, BinaryOperation1 opB1, BinaryOperation2 opB2, UnaryOp opU, Initializer initObj)
{
std::size_t maxSize = 100000;
Sequence<T> in1(maxSize, initObj);
Sequence<T> in2(maxSize, initObj);
for (std::size_t n = 0; n < maxSize; n = n < 16 ? n + 1 : size_t(3.1415 * n))
{
invoke_on_all_policies(test_transform_reduce(), in1.begin(), in1.begin() + n, in2.begin(), in2.begin() + n,
init, opB1, opB2, opU);
invoke_on_all_policies(test_transform_reduce(), in1.cbegin(), in1.cbegin() + n, in2.cbegin(), in2.cbegin() + n,
init, opB1, opB2, opU);
}
}
int32_t
main()
{
test_by_type<int32_t>(42, std::plus<int32_t>(), std::multiplies<int32_t>(), std::negate<int32_t>(),
[](std::size_t) -> int32_t { return int32_t(rand() % 1000); });
test_by_type<int64_t>(0, [](const int64_t& a, const int64_t& b) -> int64_t { return a | b; }, XOR(),
[](const int64_t& x) -> int64_t { return x * 2; },
[](std::size_t) -> int64_t { return int64_t(rand() % 1000); });
test_by_type<float32_t>(1.0f, std::multiplies<float32_t>(),
[](const float32_t& a, const float32_t& b) -> float32_t { return a + b; },
[](const float32_t& x) -> float32_t { return x + 2; },
[](std::size_t) -> float32_t { return rand() % 1000; });
test_by_type<MyClass>(MyClass(), std::plus<MyClass>(), std::multiplies<MyClass>(), std::negate<MyClass>(),
[](std::size_t) -> MyClass { return MyClass(rand() % 1000); });
std::cout << done() << std::endl;
return 0;
}
|
