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 "hdr/math_macros.h"
10#include "src/__support/FPUtil/FPBits.h"
11#include "src/errno/libc_errno.h"
12#include "src/math/sincosf.h"
13#include "test/UnitTest/FPMatcher.h"
14#include "test/UnitTest/Test.h"
15#include "test/src/math/sdcomp26094.h"
16#include "utils/MPFRWrapper/MPFRUtils.h"
17
18#include <errno.h>
19#include <stdint.h>
20
21using LlvmLibcSinCosfTest = LIBC_NAMESPACE::testing::FPTest<float>;
22
23using LIBC_NAMESPACE::testing::SDCOMP26094_VALUES;
24
25namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
26
27TEST_F(LlvmLibcSinCosfTest, SpecialNumbers) {
28 LIBC_NAMESPACE::libc_errno = 0;
29 float sin, cos;
30
31 LIBC_NAMESPACE::sincosf(x: aNaN, sinx: &sin, cosx: &cos);
32 EXPECT_FP_EQ(aNaN, cos);
33 EXPECT_FP_EQ(aNaN, sin);
34 EXPECT_MATH_ERRNO(0);
35
36 LIBC_NAMESPACE::sincosf(x: 0.0f, sinx: &sin, cosx: &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(x: -0.0f, sinx: &sin, cosx: &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(x: inf, sinx: &sin, cosx: &cos);
47 EXPECT_FP_EQ(aNaN, cos);
48 EXPECT_FP_EQ(aNaN, sin);
49 EXPECT_MATH_ERRNO(EDOM);
50
51 LIBC_NAMESPACE::sincosf(x: neg_inf, sinx: &sin, cosx: &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
99TEST_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 = FPBits(v).get_val();
104 if (isnan(x: x) || isinf(x: 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.
113TEST_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 = FPBits(INPUTS[i]).get_val();
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.
170TEST_F(LlvmLibcSinCosfTest, SDCOMP_26094) {
171 for (uint32_t v : SDCOMP26094_VALUES) {
172 float x = FPBits(v).get_val();
173 EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
174 EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);
175 }
176}
177

source code of libc/test/src/math/sincosf_test.cpp