Initial PSTL commit
[lldb.git] / pstl / test / test_transform_binary.cpp
1 // -*- C++ -*-
2 //===-- test_transform_binary.cpp -----------------------------------------===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10
11 #include "pstl/execution"
12 #include "pstl/algorithm"
13 #include "utils.h"
14
15 using namespace TestUtils;
16
17 template <typename In1, typename In2, typename Out>
18 class TheOperation
19 {
20     Out val;
21
22   public:
23     TheOperation(Out v) : val(v) {}
24     Out
25     operator()(const In1& x, const In2& y) const
26     {
27         return Out(val + x - y);
28     }
29 };
30
31 template <typename InputIterator1, typename InputIterator2, typename OutputIterator>
32 void
33 check_and_reset(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator out_first)
34 {
35     typedef typename std::iterator_traits<OutputIterator>::value_type Out;
36     typename std::iterator_traits<OutputIterator>::difference_type k = 0;
37     for (; first1 != last1; ++first1, ++first2, ++out_first, ++k)
38     {
39         // check
40         Out expected = Out(1.5) + *first1 - *first2;
41         Out actual = *out_first;
42         if (std::is_floating_point<Out>::value)
43         {
44             EXPECT_TRUE((expected > actual ? expected - actual : actual - expected) < 1e7,
45                         "wrong value in output sequence");
46         }
47         else
48         {
49             EXPECT_EQ(expected, actual, "wrong value in output sequence");
50         }
51         // reset
52         *out_first = k % 7 != 4 ? 7 * k - 5 : 0;
53     }
54 }
55
56 struct test_one_policy
57 {
58     template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,
59               typename BinaryOp>
60     void
61     operator()(Policy&& exec, InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,
62                OutputIterator out_first, OutputIterator out_last, BinaryOp op)
63     {
64         auto orrr = std::transform(exec, first1, last1, first2, out_first, op);
65         check_and_reset(first1, last1, first2, out_first);
66     }
67 };
68
69 template <typename In1, typename In2, typename Out, typename Predicate>
70 void
71 test(Predicate pred)
72 {
73     for (size_t n = 0; n <= 100000; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
74     {
75         Sequence<In1> in1(n, [](size_t k) { return k % 5 != 1 ? 3 * k - 7 : 0; });
76         Sequence<In2> in2(n, [](size_t k) { return k % 7 != 2 ? 5 * k - 5 : 0; });
77
78         Sequence<Out> out(n, [](size_t k) { return -1; });
79
80         invoke_on_all_policies(test_one_policy(), in1.begin(), in1.end(), in2.begin(), in2.end(), out.begin(),
81                                out.end(), pred);
82         invoke_on_all_policies(test_one_policy(), in1.cbegin(), in1.cend(), in2.cbegin(), in2.cend(), out.begin(),
83                                out.end(), pred);
84     }
85 }
86
87 template <typename T>
88 struct test_non_const
89 {
90     template <typename Policy, typename InputIterator, typename OutputInterator>
91     void
92     operator()(Policy&& exec, InputIterator input_iter, OutputInterator out_iter)
93     {
94         invoke_if(exec, [&]() {
95             InputIterator input_iter2 = input_iter;
96             transform(exec, input_iter, input_iter, input_iter2, out_iter, non_const(std::plus<T>()));
97         });
98     }
99 };
100
101 int32_t
102 main()
103 {
104     //const operator()
105     test<int32_t, int32_t, int32_t>(TheOperation<int32_t, int32_t, int32_t>(1));
106     test<float32_t, float32_t, float32_t>(TheOperation<float32_t, float32_t, float32_t>(1.5));
107     //non-const operator()
108     test<int32_t, float32_t, float32_t>(non_const(TheOperation<int32_t, float32_t, float32_t>(1.5)));
109     test<int64_t, float64_t, float32_t>(non_const(TheOperation<int64_t, float64_t, float32_t>(1.5)));
110     //lambda
111     test<int8_t, float64_t, int8_t>([](const int8_t& x, const float64_t& y) { return int8_t(int8_t(1.5) + x - y); });
112
113     test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
114
115     std::cout << done() << std::endl;
116     return 0;
117 }