1 //===-- Unittests for expf ------------------------------------------------===// 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/expf.h" 13 #include "utils/FPUtil/BitPatterns.h" 14 #include "utils/FPUtil/ClassificationFunctions.h" 15 #include "utils/FPUtil/FloatOperations.h" 16 #include "utils/FPUtil/FloatProperties.h" 17 #include "utils/MPFRWrapper/MPFRUtils.h" 18 #include "utils/UnitTest/Test.h" 19 20 #include <stdint.h> 21 22 using __llvm_libc::fputil::isNegativeQuietNaN; 23 using __llvm_libc::fputil::isQuietNaN; 24 using __llvm_libc::fputil::valueAsBits; 25 using __llvm_libc::fputil::valueFromBits; 26 27 using BitPatterns = __llvm_libc::fputil::BitPatterns<float>; 28 29 namespace mpfr = __llvm_libc::testing::mpfr; 30 31 // 12 additional bits of precision over the base precision of a |float| 32 // value. 33 static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 12, 34 0xFFF}; 35 36 TEST(ExpfTest, SpecialNumbers) { 37 llvmlibc_errno = 0; 38 39 EXPECT_TRUE( 40 isQuietNaN(__llvm_libc::expf(valueFromBits(BitPatterns::aQuietNaN)))); 41 EXPECT_EQ(llvmlibc_errno, 0); 42 43 EXPECT_TRUE(isNegativeQuietNaN( 44 __llvm_libc::expf(valueFromBits(BitPatterns::aNegativeQuietNaN)))); 45 EXPECT_EQ(llvmlibc_errno, 0); 46 47 EXPECT_TRUE(isQuietNaN( 48 __llvm_libc::expf(valueFromBits(BitPatterns::aSignallingNaN)))); 49 EXPECT_EQ(llvmlibc_errno, 0); 50 51 EXPECT_TRUE(isNegativeQuietNaN( 52 __llvm_libc::expf(valueFromBits(BitPatterns::aNegativeSignallingNaN)))); 53 EXPECT_EQ(llvmlibc_errno, 0); 54 55 EXPECT_EQ(BitPatterns::inf, 56 valueAsBits(__llvm_libc::expf(valueFromBits(BitPatterns::inf)))); 57 EXPECT_EQ(llvmlibc_errno, 0); 58 59 EXPECT_EQ(BitPatterns::zero, 60 valueAsBits(__llvm_libc::expf(valueFromBits(BitPatterns::negInf)))); 61 EXPECT_EQ(llvmlibc_errno, 0); 62 63 EXPECT_EQ(BitPatterns::one, 64 valueAsBits(__llvm_libc::expf(valueFromBits(BitPatterns::zero)))); 65 EXPECT_EQ(llvmlibc_errno, 0); 66 67 EXPECT_EQ(BitPatterns::one, valueAsBits(__llvm_libc::expf( 68 valueFromBits(BitPatterns::negZero)))); 69 EXPECT_EQ(llvmlibc_errno, 0); 70 } 71 72 TEST(ExpfTest, Overflow) { 73 llvmlibc_errno = 0; 74 EXPECT_EQ(BitPatterns::inf, 75 valueAsBits(__llvm_libc::expf(valueFromBits(0x7f7fffffU)))); 76 EXPECT_EQ(llvmlibc_errno, ERANGE); 77 78 llvmlibc_errno = 0; 79 EXPECT_EQ(BitPatterns::inf, 80 valueAsBits(__llvm_libc::expf(valueFromBits(0x42cffff8U)))); 81 EXPECT_EQ(llvmlibc_errno, ERANGE); 82 83 llvmlibc_errno = 0; 84 EXPECT_EQ(BitPatterns::inf, 85 valueAsBits(__llvm_libc::expf(valueFromBits(0x42d00008U)))); 86 EXPECT_EQ(llvmlibc_errno, ERANGE); 87 } 88 89 TEST(ExpfTest, Underflow) { 90 llvmlibc_errno = 0; 91 EXPECT_EQ(BitPatterns::zero, 92 valueAsBits(__llvm_libc::expf(valueFromBits(0xff7fffffU)))); 93 EXPECT_EQ(llvmlibc_errno, ERANGE); 94 95 llvmlibc_errno = 0; 96 EXPECT_EQ(BitPatterns::zero, 97 valueAsBits(__llvm_libc::expf(valueFromBits(0xc2cffff8U)))); 98 EXPECT_EQ(llvmlibc_errno, ERANGE); 99 100 llvmlibc_errno = 0; 101 EXPECT_EQ(BitPatterns::zero, 102 valueAsBits(__llvm_libc::expf(valueFromBits(0xc2d00008U)))); 103 EXPECT_EQ(llvmlibc_errno, ERANGE); 104 } 105 106 // Test with inputs which are the borders of underflow/overflow but still 107 // produce valid results without setting errno. 108 TEST(ExpfTest, Borderline) { 109 float x; 110 111 llvmlibc_errno = 0; 112 x = valueFromBits(0x42affff8U); 113 ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), tolerance); 114 EXPECT_EQ(llvmlibc_errno, 0); 115 116 x = valueFromBits(0x42b00008U); 117 ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), tolerance); 118 EXPECT_EQ(llvmlibc_errno, 0); 119 120 x = valueFromBits(0xc2affff8U); 121 ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), tolerance); 122 EXPECT_EQ(llvmlibc_errno, 0); 123 124 x = valueFromBits(0xc2b00008U); 125 ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), tolerance); 126 EXPECT_EQ(llvmlibc_errno, 0); 127 } 128 129 TEST(ExpfTest, InFloatRange) { 130 constexpr uint32_t count = 1000000; 131 constexpr uint32_t step = UINT32_MAX / count; 132 for (uint32_t i = 0, v = 0; i <= count; ++i, v += step) { 133 float x = valueFromBits(v); 134 if (isnan(x) || isinf(x)) 135 continue; 136 llvmlibc_errno = 0; 137 float result = __llvm_libc::expf(x); 138 139 // If the computation resulted in an error or did not produce valid result 140 // in the single-precision floating point range, then ignore comparing with 141 // MPFR result as MPFR can still produce valid results because of its 142 // wider precision. 143 if (isnan(result) || isinf(result) || llvmlibc_errno != 0) 144 continue; 145 ASSERT_MPFR_MATCH(mpfr::Operation::Exp, x, __llvm_libc::expf(x), tolerance); 146 } 147 } 148