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 "include/errno.h" 10 #include "include/math.h" 11 #include "src/errno/llvmlibc_errno.h" 12 #include "src/math/sincosf.h" 13 #include "test/src/math/sdcomp26094.h" 14 #include "utils/CPP/Array.h" 15 #include "utils/FPUtil/BitPatterns.h" 16 #include "utils/FPUtil/ClassificationFunctions.h" 17 #include "utils/FPUtil/FloatOperations.h" 18 #include "utils/FPUtil/FloatProperties.h" 19 #include "utils/MPFRWrapper/MPFRUtils.h" 20 #include "utils/UnitTest/Test.h" 21 22 #include <stdint.h> 23 24 using __llvm_libc::fputil::isNegativeQuietNaN; 25 using __llvm_libc::fputil::isQuietNaN; 26 using __llvm_libc::fputil::valueAsBits; 27 using __llvm_libc::fputil::valueFromBits; 28 29 using BitPatterns = __llvm_libc::fputil::BitPatterns<float>; 30 31 using __llvm_libc::testing::sdcomp26094Values; 32 33 namespace mpfr = __llvm_libc::testing::mpfr; 34 35 // 12 additional bits of precision over the base precision of a |float| 36 // value. 37 static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 12, 38 3 * 0x1000 / 4}; 39 40 TEST(SinCosfTest, SpecialNumbers) { 41 llvmlibc_errno = 0; 42 float sin, cos; 43 44 __llvm_libc::sincosf(valueFromBits(BitPatterns::aQuietNaN), &sin, &cos); 45 EXPECT_TRUE(isQuietNaN(cos)); 46 EXPECT_TRUE(isQuietNaN(sin)); 47 EXPECT_EQ(llvmlibc_errno, 0); 48 49 __llvm_libc::sincosf(valueFromBits(BitPatterns::aNegativeQuietNaN), &sin, 50 &cos); 51 EXPECT_TRUE(isNegativeQuietNaN(cos)); 52 EXPECT_TRUE(isNegativeQuietNaN(sin)); 53 EXPECT_EQ(llvmlibc_errno, 0); 54 55 __llvm_libc::sincosf(valueFromBits(BitPatterns::aSignallingNaN), &sin, &cos); 56 EXPECT_TRUE(isQuietNaN(cos)); 57 EXPECT_TRUE(isQuietNaN(sin)); 58 EXPECT_EQ(llvmlibc_errno, 0); 59 60 __llvm_libc::sincosf(valueFromBits(BitPatterns::aNegativeSignallingNaN), &sin, 61 &cos); 62 EXPECT_TRUE(isNegativeQuietNaN(cos)); 63 EXPECT_TRUE(isNegativeQuietNaN(sin)); 64 EXPECT_EQ(llvmlibc_errno, 0); 65 66 __llvm_libc::sincosf(valueFromBits(BitPatterns::zero), &sin, &cos); 67 EXPECT_EQ(BitPatterns::one, valueAsBits(cos)); 68 EXPECT_EQ(BitPatterns::zero, valueAsBits(sin)); 69 EXPECT_EQ(llvmlibc_errno, 0); 70 71 __llvm_libc::sincosf(valueFromBits(BitPatterns::negZero), &sin, &cos); 72 EXPECT_EQ(BitPatterns::one, valueAsBits(cos)); 73 EXPECT_EQ(BitPatterns::negZero, valueAsBits(sin)); 74 EXPECT_EQ(llvmlibc_errno, 0); 75 76 llvmlibc_errno = 0; 77 __llvm_libc::sincosf(valueFromBits(BitPatterns::inf), &sin, &cos); 78 EXPECT_TRUE(isQuietNaN(cos)); 79 EXPECT_TRUE(isQuietNaN(sin)); 80 EXPECT_EQ(llvmlibc_errno, EDOM); 81 82 llvmlibc_errno = 0; 83 __llvm_libc::sincosf(valueFromBits(BitPatterns::negInf), &sin, &cos); 84 EXPECT_TRUE(isQuietNaN(cos)); 85 EXPECT_TRUE(isQuietNaN(sin)); 86 EXPECT_EQ(llvmlibc_errno, EDOM); 87 } 88 89 TEST(SinCosfTest, InFloatRange) { 90 constexpr uint32_t count = 1000000; 91 constexpr uint32_t step = UINT32_MAX / count; 92 for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { 93 float x = valueFromBits(v); 94 if (isnan(x) || isinf(x)) 95 continue; 96 97 float sin, cos; 98 __llvm_libc::sincosf(x, &sin, &cos); 99 ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, cos, tolerance); 100 ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, sin, tolerance); 101 } 102 } 103 104 // For small values, cos(x) is 1 and sin(x) is x. 105 TEST(SinCosfTest, SmallValues) { 106 uint32_t bits = 0x17800000; 107 float x = valueFromBits(bits); 108 float result_cos, result_sin; 109 __llvm_libc::sincosf(x, &result_sin, &result_cos); 110 EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result_cos, tolerance); 111 EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, result_sin, tolerance); 112 EXPECT_EQ(BitPatterns::one, valueAsBits(result_cos)); 113 EXPECT_EQ(bits, valueAsBits(result_sin)); 114 115 bits = 0x00400000; 116 x = valueFromBits(bits); 117 __llvm_libc::sincosf(x, &result_sin, &result_cos); 118 EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, result_cos, tolerance); 119 EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, result_sin, tolerance); 120 EXPECT_EQ(BitPatterns::one, valueAsBits(result_cos)); 121 EXPECT_EQ(bits, valueAsBits(result_sin)); 122 } 123 124 // SDCOMP-26094: check sinf in the cases for which the range reducer 125 // returns values furthest beyond its nominal upper bound of pi/4. 126 TEST(SinCosfTest, SDCOMP_26094) { 127 for (uint32_t v : sdcomp26094Values) { 128 float x = valueFromBits(v); 129 float sin, cos; 130 __llvm_libc::sincosf(x, &sin, &cos); 131 EXPECT_MPFR_MATCH(mpfr::Operation::Cos, x, cos, tolerance); 132 EXPECT_MPFR_MATCH(mpfr::Operation::Sin, x, sin, tolerance); 133 } 134 } 135