libc/test/src/math/sincosf_test.cpp

   1 //===-- Unittests for sincosf ---------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "src/__support/FPUtil/FPBits.h"
  10 #include "src/errno/libc_errno.h"
  11 #include "src/math/sincosf.h"
  12 #include "test/UnitTest/FPMatcher.h"
  13 #include "test/UnitTest/Test.h"
  14 #include "test/src/math/sdcomp26094.h"
  15 #include "utils/MPFRWrapper/MPFRUtils.h"
  16 #include <math.h>
  17
  18 #include <errno.h>
  19 #include <stdint.h>
  20
  21 using LlvmLibcSinCosfTest = LIBC_NAMESPACE::testing::FPTest<float>;
  22
  23 using LIBC_NAMESPACE::testing::SDCOMP26094_VALUES;
  24
  25 namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
  26
  27 TEST_F(LlvmLibcSinCosfTest, SpecialNumbers) {
  28   libc_errno = 0;
  29   float sin, cos;
  30
  31   LIBC_NAMESPACE::sincosf(aNaN, &sin, &cos);
  32   EXPECT_FP_EQ(aNaN, cos);
  33   EXPECT_FP_EQ(aNaN, sin);
  34   EXPECT_MATH_ERRNO(0);
  35
  36   LIBC_NAMESPACE::sincosf(0.0f, &sin, &cos);
  37   EXPECT_FP_EQ(1.0f, cos);
  38   EXPECT_FP_EQ(0.0f, sin);
  39   EXPECT_MATH_ERRNO(0);
  40
  41   LIBC_NAMESPACE::sincosf(-0.0f, &sin, &cos);
  42   EXPECT_FP_EQ(1.0f, cos);
  43   EXPECT_FP_EQ(-0.0f, sin);
  44   EXPECT_MATH_ERRNO(0);
  45
  46   LIBC_NAMESPACE::sincosf(inf, &sin, &cos);
  47   EXPECT_FP_EQ(aNaN, cos);
  48   EXPECT_FP_EQ(aNaN, sin);
  49   EXPECT_MATH_ERRNO(EDOM);
  50
  51   LIBC_NAMESPACE::sincosf(neg_inf, &sin, &cos);
  52   EXPECT_FP_EQ(aNaN, cos);
  53   EXPECT_FP_EQ(aNaN, sin);
  54   EXPECT_MATH_ERRNO(EDOM);
  55 }
  56
  57 #define EXPECT_SINCOS_MATCH_ALL_ROUNDING(input)                                \
  58   {                                                                            \
  59     float sin, cos;                                                            \
  60     namespace mpfr = LIBC_NAMESPACE::testing::mpfr;                            \
  61                                                                                \
  62     mpfr::ForceRoundingMode __r1(mpfr::RoundingMode::Nearest);                 \
  63     if (__r1.success) {                                                        \
  64       LIBC_NAMESPACE::sincosf(input, &sin, &cos);                              \
  65       EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5,                 \
  66                         mpfr::RoundingMode::Nearest);                          \
  67       EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5,                 \
  68                         mpfr::RoundingMode::Nearest);                          \
  69     }                                                                          \
  70                                                                                \
  71     mpfr::ForceRoundingMode __r2(mpfr::RoundingMode::Upward);                  \
  72     if (__r2.success) {                                                        \
  73       LIBC_NAMESPACE::sincosf(input, &sin, &cos);                              \
  74       EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5,                 \
  75                         mpfr::RoundingMode::Upward);                           \
  76       EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5,                 \
  77                         mpfr::RoundingMode::Upward);                           \
  78     }                                                                          \
  79                                                                                \
  80     mpfr::ForceRoundingMode __r3(mpfr::RoundingMode::Downward);                \
  81     if (__r3.success) {                                                        \
  82       LIBC_NAMESPACE::sincosf(input, &sin, &cos);                              \
  83       EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5,                 \
  84                         mpfr::RoundingMode::Downward);                         \
  85       EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5,                 \
  86                         mpfr::RoundingMode::Downward);                         \
  87     }                                                                          \
  88                                                                                \
  89     mpfr::ForceRoundingMode __r4(mpfr::RoundingMode::TowardZero);              \
  90     if (__r4.success) {                                                        \
  91       LIBC_NAMESPACE::sincosf(input, &sin, &cos);                              \
  92       EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5,                 \
  93                         mpfr::RoundingMode::TowardZero);                       \
  94       EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5,                 \
  95                         mpfr::RoundingMode::TowardZero);                       \
  96     }                                                                          \
  97   }
  98
  99 TEST_F(LlvmLibcSinCosfTest, InFloatRange) {
 100   constexpr uint32_t COUNT = 1'001;
 101   constexpr uint32_t STEP = UINT32_MAX / COUNT;
 102   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
 103     float x = float(FPBits((v)));
 104     if (isnan(x) || isinf(x))
 105       continue;
 106
 107     EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
 108     EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
 109   }
 110 }
 111
 112 // For hard to round inputs.
 113 TEST_F(LlvmLibcSinCosfTest, SpecialValues) {
 114   constexpr int N = 43;
 115   constexpr uint32_t INPUTS[N] = {
 116       0x3b56'37f5U, // x = 0x1.ac6feap-9f
 117       0x3f06'0a92U, // x = pi/6
 118       0x3f3a'dc51U, // x = 0x1.75b8a2p-1f
 119       0x3f49'0fdbU, // x = pi/4
 120       0x3f86'0a92U, // x = pi/3
 121       0x3fa7'832aU, // x = 0x1.4f0654p+0f
 122       0x3fc9'0fdbU, // x = pi/2
 123       0x4017'1973U, // x = 0x1.2e32e6p+1f
 124       0x4049'0fdbU, // x = pi
 125       0x4096'cbe4U, // x = 0x1.2d97c8p+2f
 126       0x40c9'0fdbU, // x = 2*pi
 127       0x433b'7490U, // x = 0x1.76e92p+7f
 128       0x437c'e5f1U, // x = 0x1.f9cbe2p+7f
 129       0x4619'9998U, // x = 0x1.33333p+13f
 130       0x474d'246fU, // x = 0x1.9a48dep+15f
 131       0x4afd'ece4U, // x = 0x1.fbd9c8p+22f
 132       0x4c23'32e9U, // x = 0x1.4665d2p+25f
 133       0x50a3'e87fU, // x = 0x1.47d0fep+34f
 134       0x5239'47f6U, // x = 0x1.728fecp+37f
 135       0x53b1'46a6U, // x = 0x1.628d4cp+40f
 136       0x5532'5019U, // x = 0x1.64a032p+43f
 137       0x55ca'fb2aU, // x = 0x1.95f654p+44f
 138       0x588e'f060U, // x = 0x1.1de0cp+50f
 139       0x5922'aa80U, // x = 0x1.4555p+51f
 140       0x5aa4'542cU, // x = 0x1.48a858p+54f
 141       0x5c07'bcd0U, // x = 0x1.0f79ap+57f
 142       0x5ebc'fddeU, // x = 0x1.79fbbcp+62f
 143       0x5f18'b878U, // x = 0x1.3170fp+63f
 144       0x5fa6'eba7U, // x = 0x1.4dd74ep+64f
 145       0x6115'cb11U, // x = 0x1.2b9622p+67f
 146       0x61a4'0b40U, // x = 0x1.48168p+68f
 147       0x6386'134eU, // x = 0x1.0c269cp+72f
 148       0x6589'8498U, // x = 0x1.13093p+76f
 149       0x6600'0001U, // x = 0x1.000002p+77f
 150       0x664e'46e4U, // x = 0x1.9c8dc8p+77f
 151       0x66b0'14aaU, // x = 0x1.602954p+78f
 152       0x67a9'242bU, // x = 0x1.524856p+80f
 153       0x6a19'76f1U, // x = 0x1.32ede2p+85f
 154       0x6c55'da58U, // x = 0x1.abb4bp+89f
 155       0x6f79'be45U, // x = 0x1.f37c8ap+95f
 156       0x7276'69d4U, // x = 0x1.ecd3a8p+101f
 157       0x7758'4625U, // x = 0x1.b08c4ap+111f
 158       0x7bee'f5efU, // x = 0x1.ddebdep+120f
 159   };
 160
 161   for (int i = 0; i < N; ++i) {
 162     float x = float(FPBits(INPUTS[i]));
 163     EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
 164     EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
 165   }
 166 }
 167
 168 // SDCOMP-26094: check sinf in the cases for which the range reducer
 169 // returns values furthest beyond its nominal upper bound of pi/4.
 170 TEST_F(LlvmLibcSinCosfTest, SDCOMP_26094) {
 171   for (uint32_t v : SDCOMP26094_VALUES) {
 172     float x = float(FPBits((v)));
 173     EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
 174     EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
 175   }
 176 }