libc/test/src/math/sinf_test.cpp

   1 //===-- Unittests for sinf ------------------------------------------------===//
   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/sinf.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 LlvmLibcSinfTest = 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(LlvmLibcSinfTest, SpecialNumbers) {
  28   libc_errno = 0;
  29
  30   EXPECT_FP_EQ(aNaN, LIBC_NAMESPACE::sinf(aNaN));
  31   EXPECT_MATH_ERRNO(0);
  32
  33   EXPECT_FP_EQ(0.0f, LIBC_NAMESPACE::sinf(0.0f));
  34   EXPECT_MATH_ERRNO(0);
  35
  36   EXPECT_FP_EQ(-0.0f, LIBC_NAMESPACE::sinf(-0.0f));
  37   EXPECT_MATH_ERRNO(0);
  38
  39   EXPECT_FP_EQ(aNaN, LIBC_NAMESPACE::sinf(inf));
  40   EXPECT_MATH_ERRNO(EDOM);
  41
  42   EXPECT_FP_EQ(aNaN, LIBC_NAMESPACE::sinf(neg_inf));
  43   EXPECT_MATH_ERRNO(EDOM);
  44 }
  45
  46 TEST_F(LlvmLibcSinfTest, InFloatRange) {
  47   constexpr uint32_t COUNT = 100'000;
  48   constexpr uint32_t STEP = UINT32_MAX / COUNT;
  49   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
  50     float x = float(FPBits(v));
  51     if (isnan(x) || isinf(x))
  52       continue;
  53     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
  54                                    LIBC_NAMESPACE::sinf(x), 0.5);
  55   }
  56 }
  57
  58 TEST_F(LlvmLibcSinfTest, SpecificBitPatterns) {
  59   constexpr int N = 36;
  60   constexpr uint32_t INPUTS[N] = {
  61       0x3f06'0a92U, // x = pi/6
  62       0x3f3a'dc51U, // x = 0x1.75b8a2p-1f
  63       0x3f49'0fdbU, // x = pi/4
  64       0x3f86'0a92U, // x = pi/3
  65       0x3fa7'832aU, // x = 0x1.4f0654p+0f
  66       0x3fc9'0fdbU, // x = pi/2
  67       0x4017'1973U, // x = 0x1.2e32e6p+1f
  68       0x4049'0fdbU, // x = pi
  69       0x4096'cbe4U, // x = 0x1.2d97c8p+2f
  70       0x40c9'0fdbU, // x = 2*pi
  71       0x433b'7490U, // x = 0x1.76e92p+7f
  72       0x437c'e5f1U, // x = 0x1.f9cbe2p+7f
  73       0x4619'9998U, // x = 0x1.33333p+13f
  74       0x474d'246fU, // x = 0x1.9a48dep+15f
  75       0x4afd'ece4U, // x = 0x1.fbd9c8p+22f
  76       0x4c23'32e9U, // x = 0x1.4665d2p+25f
  77       0x50a3'e87fU, // x = 0x1.47d0fep+34f
  78       0x5239'47f6U, // x = 0x1.728fecp+37f
  79       0x53b1'46a6U, // x = 0x1.628d4cp+40f
  80       0x55ca'fb2aU, // x = 0x1.95f654p+44f
  81       0x588e'f060U, // x = 0x1.1de0cp+50f
  82       0x5c07'bcd0U, // x = 0x1.0f79ap+57f
  83       0x5ebc'fddeU, // x = 0x1.79fbbcp+62f
  84       0x5fa6'eba7U, // x = 0x1.4dd74ep+64f
  85       0x61a4'0b40U, // x = 0x1.48168p+68f
  86       0x6386'134eU, // x = 0x1.0c269cp+72f
  87       0x6589'8498U, // x = 0x1.13093p+76f
  88       0x6600'0001U, // x = 0x1.000002p+77f
  89       0x664e'46e4U, // x = 0x1.9c8dc8p+77f
  90       0x66b0'14aaU, // x = 0x1.602954p+78f
  91       0x67a9'242bU, // x = 0x1.524856p+80f
  92       0x6a19'76f1U, // x = 0x1.32ede2p+85f
  93       0x6c55'da58U, // x = 0x1.abb4bp+89f
  94       0x6f79'be45U, // x = 0x1.f37c8ap+95f
  95       0x7276'69d4U, // x = 0x1.ecd3a8p+101f
  96       0x7758'4625U, // x = 0x1.b08c4ap+111f
  97   };
  98
  99   for (int i = 0; i < N; ++i) {
 100     float x = float(FPBits(INPUTS[i]));
 101     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
 102                                    LIBC_NAMESPACE::sinf(x), 0.5);
 103     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, -x,
 104                                    LIBC_NAMESPACE::sinf(-x), 0.5);
 105   }
 106 }
 107
 108 // For small values, sin(x) is x.
 109 TEST_F(LlvmLibcSinfTest, SmallValues) {
 110   float x = float(FPBits(0x1780'0000U));
 111   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
 112                                  LIBC_NAMESPACE::sinf(x), 0.5);
 113
 114   x = float(FPBits(0x0040'0000U));
 115   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
 116                                  LIBC_NAMESPACE::sinf(x), 0.5);
 117 }
 118
 119 // SDCOMP-26094: check sinf in the cases for which the range reducer
 120 // returns values furthest beyond its nominal upper bound of pi/4.
 121 TEST_F(LlvmLibcSinfTest, SDCOMP_26094) {
 122   for (uint32_t v : SDCOMP26094_VALUES) {
 123     float x = float(FPBits((v)));
 124     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
 125                                    LIBC_NAMESPACE::sinf(x), 0.5);
 126   }
 127 }