pstl/test/std/numerics/numeric.ops/adjacent_difference.pass.cpp

   1 // -*- C++ -*-
   2 //===-- adjacent_difference.pass.cpp --------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // UNSUPPORTED: c++03, c++11, c++14
  11
  12 #include "support/pstl_test_config.h"
  13
  14 #include <iterator>
  15 #include <execution>
  16 #include <numeric>
  17
  18 #include "support/utils.h"
  19
  20 using namespace TestUtils;
  21
  22 template <typename T>
  23 struct wrapper
  24 {
  25     T t;
  26     constexpr explicit wrapper(T t_) : t(t_) {}
  27     template <typename T2>
  28     constexpr wrapper(const wrapper<T2>& a)
  29     {
  30         t = a.t;
  31     }
  32     template <typename T2>
  33     constexpr void
  34     operator=(const wrapper<T2>& a)
  35     {
  36         t = a.t;
  37     }
  38     constexpr wrapper<T>
  39     operator-(const wrapper<T>& a) const
  40     {
  41         return wrapper<T>(t - a.t);
  42     }
  43 };
  44
  45 template <typename T>
  46 bool
  47 compare(const T& a, const T& b)
  48 {
  49     return a == b;
  50 }
  51
  52 template <typename T>
  53 bool
  54 compare(const wrapper<T>& a, const wrapper<T>& b)
  55 {
  56     return a.t == b.t;
  57 }
  58
  59 template <typename Iterator1, typename Iterator2, typename T, typename Function>
  60 typename std::enable_if<!std::is_floating_point<T>::value, bool>::type
  61 compute_and_check(Iterator1 first, Iterator1 last, Iterator2 d_first, T, Function f)
  62 {
  63     using T2 = typename std::iterator_traits<Iterator2>::value_type;
  64
  65     if (first == last)
  66         return true;
  67
  68     {
  69         T2 temp(*first);
  70         if (!compare(temp, *d_first))
  71             return false;
  72     }
  73     Iterator1 second = std::next(first);
  74
  75     ++d_first;
  76     for (; second != last; ++first, ++second, ++d_first)
  77     {
  78         T2 temp(f(*second, *first));
  79         if (!compare(temp, *d_first))
  80             return false;
  81     }
  82
  83     return true;
  84 }
  85
  86 // we don't want to check equality here
  87 // because we can't be sure it will be strictly equal for floating point types
  88 template <typename Iterator1, typename Iterator2, typename T, typename Function>
  89 typename std::enable_if<std::is_floating_point<T>::value, bool>::type compute_and_check(Iterator1, Iterator1, Iterator2,
  90                                                                                         T, Function)
  91 {
  92     return true;
  93 }
  94
  95 struct test_one_policy
  96 {
  97 #if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) ||                                                             \
  98     defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
  99     template <typename Iterator1, typename Iterator2, typename T, typename Function>
 100     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
 101     operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
 102                Iterator2 actual_e, T trash, Function f)
 103     {
 104     }
 105     template <typename Iterator1, typename Iterator2, typename T, typename Function>
 106     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
 107     operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
 108                Iterator2 actual_e, T trash, Function f)
 109     {
 110     }
 111 #endif
 112
 113     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename T, typename Function>
 114     void
 115     operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e,
 116                T trash, Function f)
 117     {
 118         using namespace std;
 119         using T2 = typename std::iterator_traits<Iterator1>::value_type;
 120
 121         fill(actual_b, actual_e, trash);
 122
 123         Iterator2 actual_return = adjacent_difference(exec, data_b, data_e, actual_b);
 124         EXPECT_TRUE(compute_and_check(data_b, data_e, actual_b, T2(0), std::minus<T2>()),
 125                     "wrong effect of adjacent_difference");
 126         EXPECT_TRUE(actual_return == actual_e, "wrong result of adjacent_difference");
 127
 128         fill(actual_b, actual_e, trash);
 129
 130         actual_return = adjacent_difference(exec, data_b, data_e, actual_b, f);
 131         EXPECT_TRUE(compute_and_check(data_b, data_e, actual_b, T2(0), f),
 132                     "wrong effect of adjacent_difference with functor");
 133         EXPECT_TRUE(actual_return == actual_e, "wrong result of adjacent_difference with functor");
 134     }
 135 };
 136
 137 template <typename T1, typename T2, typename Pred>
 138 void
 139 test(Pred pred)
 140 {
 141     const std::size_t max_len = 100000;
 142
 143     static constexpr T2 value = T2(77);
 144     static constexpr T1 trash = T1(31);
 145
 146     Sequence<T1> actual(max_len, [](std::size_t i) { return T1(i); });
 147
 148     Sequence<T2> data(max_len, [](std::size_t i) { return i % 3 == 2 ? T2(i * i) : value; });
 149
 150     for (std::size_t len = 0; len < max_len; len = len <= 16 ? len + 1 : std::size_t(3.1415 * len))
 151     {
 152         invoke_on_all_policies(test_one_policy(), data.begin(), data.begin() + len, actual.begin(),
 153                                actual.begin() + len, trash, pred);
 154         invoke_on_all_policies(test_one_policy(), data.cbegin(), data.cbegin() + len, actual.begin(),
 155                                actual.begin() + len, trash, pred);
 156     }
 157 }
 158
 159 int
 160 main()
 161 {
 162     test<uint8_t, uint32_t>([](uint32_t a, uint32_t b) { return a - b; });
 163     test<int32_t, int64_t>([](int64_t a, int64_t b) { return a / (b + 1); });
 164     test<int64_t, float32_t>([](float32_t a, float32_t b) { return (a + b) / 2; });
 165     test<wrapper<int32_t>, wrapper<int64_t>>(
 166         [](const wrapper<int64_t>& a, const wrapper<int64_t>& b) { return a - b; });
 167
 168     std::cout << done() << std::endl;
 169     return 0;
 170 }