tests/math_data_test.h

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18
  19 #include <math.h>
  20 #include <fenv.h>
  21
  22 template <typename RT, typename T1>
  23 struct data_1_1_t {
  24   RT expected;
  25   T1 input;
  26 };
  27
  28 template <typename T1>
  29 struct data_int_1_t {
  30   int expected;
  31   T1 input;
  32 };
  33
  34 template <typename T1>
  35 struct data_long_1_t {
  36   long expected;
  37   T1 input;
  38 };
  39
  40 template <typename T1>
  41 struct data_llong_1_t {
  42   long long expected;
  43   T1 input;
  44 };
  45
  46 template <typename RT, typename T1, typename T2>
  47 struct data_1_2_t {
  48   RT expected;
  49   T1 input1;
  50   T2 input2;
  51 };
  52
  53 template <typename RT1, typename RT2, typename T>
  54 struct data_2_1_t {
  55   RT1 expected1;
  56   RT2 expected2;
  57   T input;
  58 };
  59
  60 template <typename RT1, typename T>
  61 struct data_1_int_1_t {
  62   RT1 expected1;
  63   int expected2;
  64   T input;
  65 };
  66
  67 template <typename RT1, typename T1, typename T2>
  68 struct data_1_int_2_t {
  69   RT1 expected1;
  70   int expected2;
  71   T1 input1;
  72   T2 input2;
  73 };
  74
  75 template <typename RT, typename T1, typename T2, typename T3>
  76 struct data_1_3_t {
  77   RT expected;
  78   T1 input1;
  79   T2 input2;
  80   T3 input3;
  81 };
  82
  83 template <typename T> union fp_u;
  84
  85 template <> union fp_u<float> {
  86   float value;
  87   struct {
  88     unsigned frac:23;
  89     unsigned exp:8;
  90     unsigned sign:1;
  91   } bits;
  92   uint32_t sign_magnitude;
  93 };
  94
  95 template <> union fp_u<double> {
  96   double value;
  97   struct {
  98     unsigned fracl;
  99     unsigned frach:20;
 100     unsigned exp:11;
 101     unsigned sign:1;
 102   } bits;
 103   uint64_t sign_magnitude;
 104 };
 105
 106 template <> union fp_u<long double> {
 107   long double value;
 108 #if defined(__LP64__)
 109   struct {
 110     unsigned fracl;
 111     unsigned fraclm;
 112     unsigned frachm;
 113     unsigned frach:16;
 114     unsigned exp:15;
 115     unsigned sign:1;
 116   } bits;
 117   __int128_t sign_magnitude;
 118 #else
 119   struct {
 120       unsigned fracl;
 121       unsigned frach:20;
 122       unsigned exp:11;
 123       unsigned sign:1;
 124   } bits;
 125   uint64_t sign_magnitude;
 126 #endif
 127 };
 128
 129 template <typename T>
 130 static inline auto SignAndMagnitudeToBiased(const T& value) -> decltype(fp_u<T>::sign_magnitude) {
 131   fp_u<T> u;
 132   u.value = value;
 133   if (u.bits.sign) {
 134     return ~u.sign_magnitude + 1;
 135   } else {
 136     u.bits.sign = 1;
 137     return u.sign_magnitude;
 138   }
 139 }
 140
 141 // Based on the existing googletest implementation, which uses a fixed 4 ulp bound.
 142 template <typename T>
 143 size_t UlpDistance(T lhs, T rhs) {
 144   const auto biased1 = SignAndMagnitudeToBiased(lhs);
 145   const auto biased2 = SignAndMagnitudeToBiased(rhs);
 146   return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
 147 }
 148
 149 template <size_t ULP, typename T>
 150 struct FpUlpEq {
 151   ::testing::AssertionResult operator()(const char* /* expected_expression */,
 152                                         const char* /* actual_expression */,
 153                                         T expected,
 154                                         T actual) {
 155     if (!isnan(expected) && !isnan(actual) && UlpDistance(expected, actual) <= ULP) {
 156       return ::testing::AssertionSuccess();
 157     }
 158
 159     return ::testing::AssertionFailure()
 160         << "expected (" << std::hexfloat << expected << ") != actual (" << actual << ")";
 161   }
 162 };
 163
 164 // Runs through the array 'data' applying 'f' to each of the input values
 165 // and asserting that the result is within ULP ulps of the expected value.
 166 // For testing a (double) -> double function like sin(3).
 167 template <size_t ULP, typename RT, typename T, size_t N>
 168 void DoMathDataTest(data_1_1_t<RT, T> (&data)[N], RT f(T)) {
 169   fesetenv(FE_DFL_ENV);
 170   FpUlpEq<ULP, RT> predicate;
 171   for (size_t i = 0; i < N; ++i) {
 172     EXPECT_PRED_FORMAT2(predicate,
 173                         data[i].expected, f(data[i].input)) << "Failed on element " << i;
 174   }
 175 }
 176
 177 // Runs through the array 'data' applying 'f' to each of the input values
 178 // and asserting that the result is within ULP ulps of the expected value.
 179 // For testing a (double) -> int function like ilogb(3).
 180 template <size_t ULP, typename T, size_t N>
 181 void DoMathDataTest(data_int_1_t<T> (&data)[N], int f(T)) {
 182   fesetenv(FE_DFL_ENV);
 183   for (size_t i = 0; i < N; ++i) {
 184     EXPECT_EQ(data[i].expected, f(data[i].input)) << "Failed on element " << i;
 185   }
 186 }
 187
 188 // Runs through the array 'data' applying 'f' to each of the input values
 189 // and asserting that the result is within ULP ulps of the expected value.
 190 // For testing a (double) -> long int function like lrint(3).
 191 template <size_t ULP, typename T, size_t N>
 192 void DoMathDataTest(data_long_1_t<T> (&data)[N], long f(T)) {
 193   fesetenv(FE_DFL_ENV);
 194   for (size_t i = 0; i < N; ++i) {
 195     EXPECT_EQ(data[i].expected, f(data[i].input)) << "Failed on element " << i;
 196   }
 197 }
 198
 199 // Runs through the array 'data' applying 'f' to each of the input values
 200 // and asserting that the result is within ULP ulps of the expected value.
 201 // For testing a (double) -> long long int function like llrint(3).
 202 template <size_t ULP, typename T, size_t N>
 203 void DoMathDataTest(data_llong_1_t<T> (&data)[N], long long f(T)) {
 204   fesetenv(FE_DFL_ENV);
 205   for (size_t i = 0; i < N; ++i) {
 206     EXPECT_EQ(data[i].expected, f(data[i].input)) << "Failed on element " << i;
 207   }
 208 }
 209
 210 // Runs through the array 'data' applying 'f' to each of the pairs of input values
 211 // and asserting that the result is within ULP ulps of the expected value.
 212 // For testing a (double, double) -> double function like pow(3).
 213 template <size_t ULP, typename RT, typename T1, typename T2, size_t N>
 214 void DoMathDataTest(data_1_2_t<RT, T1, T2> (&data)[N], RT f(T1, T2)) {
 215   fesetenv(FE_DFL_ENV);
 216   FpUlpEq<ULP, RT> predicate;
 217   for (size_t i = 0; i < N; ++i) {
 218     EXPECT_PRED_FORMAT2(predicate,
 219                         data[i].expected, f(data[i].input1, data[i].input2)) << "Failed on element " << i;
 220   }
 221 }
 222
 223 // Runs through the array 'data' applying 'f' to each of the input values
 224 // and asserting that the results are within ULP ulps of the expected values.
 225 // For testing a (double, double*, double*) -> void function like sincos(3).
 226 template <size_t ULP, typename RT1, typename RT2, typename T1, size_t N>
 227 void DoMathDataTest(data_2_1_t<RT1, RT2, T1> (&data)[N], void f(T1, RT1*, RT2*)) {
 228   fesetenv(FE_DFL_ENV);
 229   FpUlpEq<ULP, RT1> predicate1;
 230   FpUlpEq<ULP, RT2> predicate2;
 231   for (size_t i = 0; i < N; ++i) {
 232     RT1 out1;
 233     RT2 out2;
 234     f(data[i].input, &out1, &out2);
 235     EXPECT_PRED_FORMAT2(predicate1, data[i].expected1, out1) << "Failed on element " << i;
 236     EXPECT_PRED_FORMAT2(predicate2, data[i].expected2, out2) << "Failed on element " << i;
 237   }
 238 }
 239
 240 // Runs through the array 'data' applying 'f' to each of the input values
 241 // and asserting that the results are within ULP ulps of the expected values.
 242 // For testing a (double, double*) -> double function like modf(3).
 243 template <size_t ULP, typename RT1, typename RT2, typename T1, size_t N>
 244 void DoMathDataTest(data_2_1_t<RT1, RT2, T1> (&data)[N], RT1 f(T1, RT2*)) {
 245   fesetenv(FE_DFL_ENV);
 246   FpUlpEq<ULP, RT1> predicate1;
 247   FpUlpEq<ULP, RT2> predicate2;
 248   for (size_t i = 0; i < N; ++i) {
 249     RT1 out1;
 250     RT2 out2;
 251     out1 = f(data[i].input, &out2);
 252     EXPECT_PRED_FORMAT2(predicate1, data[i].expected1, out1) << "Failed on element " << i;
 253     EXPECT_PRED_FORMAT2(predicate2, data[i].expected2, out2) << "Failed on element " << i;
 254   }
 255 }
 256
 257 // Runs through the array 'data' applying 'f' to each of the input values
 258 // and asserting that the results are within ULP ulps of the expected values.
 259 // For testing a (double, int*) -> double function like frexp(3).
 260 template <size_t ULP, typename RT1, typename T1, size_t N>
 261 void DoMathDataTest(data_1_int_1_t<RT1, T1> (&data)[N], RT1 f(T1, int*)) {
 262   fesetenv(FE_DFL_ENV);
 263   FpUlpEq<ULP, RT1> predicate1;
 264   for (size_t i = 0; i < N; ++i) {
 265     RT1 out1;
 266     int out2;
 267     out1 = f(data[i].input, &out2);
 268     EXPECT_PRED_FORMAT2(predicate1, data[i].expected1, out1) << "Failed on element " << i;
 269     EXPECT_EQ(data[i].expected2, out2) << "Failed on element " << i;
 270   }
 271 }
 272
 273 // Runs through the array 'data' applying 'f' to each of the input values
 274 // and asserting that the results are within ULP ulps of the expected values.
 275 // For testing a (double, double, int*) -> double function like remquo(3).
 276 template <size_t ULP, typename RT1, typename T1, typename T2, size_t N>
 277 void DoMathDataTest(data_1_int_2_t<RT1, T1, T2> (&data)[N], RT1 f(T1, T2, int*)) {
 278   fesetenv(FE_DFL_ENV);
 279   FpUlpEq<ULP, RT1> predicate1;
 280   for (size_t i = 0; i < N; ++i) {
 281     RT1 out1;
 282     int out2;
 283     out1 = f(data[i].input1, data[i].input2, &out2);
 284     EXPECT_PRED_FORMAT2(predicate1, data[i].expected1, out1) << "Failed on element " << i;
 285     EXPECT_EQ(data[i].expected2, out2) << "Failed on element " << i;
 286   }
 287 }
 288
 289 // Runs through the array 'data' applying 'f' to each of the pairs of input values
 290 // and asserting that the result is within ULP ulps of the expected value.
 291 // For testing a (double, double, double) -> double function like fma(3).
 292 template <size_t ULP, typename RT, typename T1, typename T2, typename T3, size_t N>
 293 void DoMathDataTest(data_1_3_t<RT, T1, T2, T3> (&data)[N], RT f(T1, T2, T3)) {
 294   fesetenv(FE_DFL_ENV);
 295   FpUlpEq<ULP, RT> predicate;
 296   for (size_t i = 0; i < N; ++i) {
 297     EXPECT_PRED_FORMAT2(predicate,
 298                         data[i].expected, f(data[i].input1, data[i].input2, data[i].input3)) << "Failed on element " << i;
 299   }
 300 }